﻿using System;
using System.ComponentModel;
using System.IO;
using System.Runtime.Serialization;

namespace HalconDotNet
{
	/// <summary>Represents a homogeneous 2D transformation matrix.</summary>
	// Token: 0x02000040 RID: 64
	[Serializable]
	public class HHomMat2D : HData, ISerializable, ICloneable
	{
		// Token: 0x060005D2 RID: 1490 RVA: 0x0000B2B0 File Offset: 0x000094B0
		public HHomMat2D(HTuple tuple) : base(tuple)
		{
		}

		// Token: 0x060005D3 RID: 1491 RVA: 0x0000B2B9 File Offset: 0x000094B9
		internal HHomMat2D(HData data) : base(data)
		{
		}

		// Token: 0x060005D4 RID: 1492 RVA: 0x00021028 File Offset: 0x0001F228
		internal static int LoadNew(IntPtr proc, int parIndex, HTupleType type, int err, out HHomMat2D obj)
		{
			HTuple t;
			err = HTuple.LoadNew(proc, parIndex, err, out t);
			obj = new HHomMat2D(new HData(t));
			return err;
		}

		// Token: 0x060005D5 RID: 1493 RVA: 0x00021050 File Offset: 0x0001F250
		internal static int LoadNew(IntPtr proc, int parIndex, int err, out HHomMat2D obj)
		{
			return HHomMat2D.LoadNew(proc, parIndex, HTupleType.MIXED, err, out obj);
		}

		// Token: 0x060005D6 RID: 1494 RVA: 0x0002105C File Offset: 0x0001F25C
		internal static HHomMat2D[] SplitArray(HTuple data)
		{
			int num = data.Length / 9;
			HHomMat2D[] array = new HHomMat2D[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = new HHomMat2D(new HData(data.TupleSelectRange(i * 9, (i + 1) * 9 - 1)));
			}
			return array;
		}

		/// <summary>
		///   Generate the homogeneous transformation matrix of the identical 2D transformation.
		///   Modified instance represents: Transformation matrix.
		/// </summary>
		// Token: 0x060005D7 RID: 1495 RVA: 0x000210B0 File Offset: 0x0001F2B0
		public HHomMat2D()
		{
			IntPtr proc = HalconAPI.PreCall(288);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		// Token: 0x060005D8 RID: 1496 RVA: 0x000210F4 File Offset: 0x0001F2F4
		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = this.SerializeHomMat2d();
			byte[] value = hserializedItem;
			hserializedItem.Dispose();
			info.AddValue("data", value, typeof(byte[]));
		}

		// Token: 0x060005D9 RID: 1497 RVA: 0x0002112C File Offset: 0x0001F32C
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HHomMat2D(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = new HSerializedItem((byte[])info.GetValue("data", typeof(byte[])));
			this.DeserializeHomMat2d(hserializedItem);
			hserializedItem.Dispose();
		}

		/// <summary>Serialize object to binary stream in HALCON format</summary>
		// Token: 0x060005DA RID: 1498 RVA: 0x0002116C File Offset: 0x0001F36C
		public void Serialize(Stream stream)
		{
			HSerializedItem hserializedItem = this.SerializeHomMat2d();
			hserializedItem.Serialize(stream);
			hserializedItem.Dispose();
		}

		/// <summary>Deserialize object from binary stream in HALCON format</summary>
		// Token: 0x060005DB RID: 1499 RVA: 0x00021180 File Offset: 0x0001F380
		public static HHomMat2D Deserialize(Stream stream)
		{
			HHomMat2D hhomMat2D = new HHomMat2D();
			HSerializedItem hserializedItem = HSerializedItem.Deserialize(stream);
			hhomMat2D.DeserializeHomMat2d(hserializedItem);
			hserializedItem.Dispose();
			return hhomMat2D;
		}

		// Token: 0x060005DC RID: 1500 RVA: 0x000211A6 File Offset: 0x0001F3A6
		object ICloneable.Clone()
		{
			return this.Clone();
		}

		// Token: 0x060005DD RID: 1501 RVA: 0x000211B0 File Offset: 0x0001F3B0
		public HHomMat2D Clone()
		{
			HSerializedItem hserializedItem = this.SerializeHomMat2d();
			HHomMat2D hhomMat2D = new HHomMat2D();
			hhomMat2D.DeserializeHomMat2d(hserializedItem);
			hserializedItem.Dispose();
			return hhomMat2D;
		}

		/// <summary>
		///   Read the geo coding from an ARC/INFO world file.
		///   Modified instance represents: Transformation matrix from image to world coordinates.
		/// </summary>
		/// <param name="fileName">Name of the ARC/INFO world file.</param>
		// Token: 0x060005DE RID: 1502 RVA: 0x000211D8 File Offset: 0x0001F3D8
		public void ReadWorldFile(string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(22);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Apply a projective transformation to an XLD contour.
		///   Instance represents: Homogeneous projective transformation matrix.
		/// </summary>
		/// <param name="contours">Input contours.</param>
		/// <returns>Output contours.</returns>
		// Token: 0x060005DF RID: 1503 RVA: 0x0002121C File Offset: 0x0001F41C
		public HXLDCont ProjectiveTransContourXld(HXLDCont contours)
		{
			IntPtr proc = HalconAPI.PreCall(47);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, contours);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours);
			return result;
		}

		/// <summary>
		///   Apply an arbitrary affine transformation to XLD polygons.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="polygons">Input XLD polygons.</param>
		/// <returns>Transformed XLD polygons.</returns>
		// Token: 0x060005E0 RID: 1504 RVA: 0x00021278 File Offset: 0x0001F478
		public HXLDPoly AffineTransPolygonXld(HXLDPoly polygons)
		{
			IntPtr proc = HalconAPI.PreCall(48);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, polygons);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HXLDPoly result;
			num = HXLDPoly.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(polygons);
			return result;
		}

		/// <summary>
		///   Apply an arbitrary affine 2D transformation to XLD contours.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="contours">Input XLD contours.</param>
		/// <returns>Transformed XLD contours.</returns>
		// Token: 0x060005E1 RID: 1505 RVA: 0x000212D4 File Offset: 0x0001F4D4
		public HXLDCont AffineTransContourXld(HXLDCont contours)
		{
			IntPtr proc = HalconAPI.PreCall(49);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, contours);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours);
			return result;
		}

		/// <summary>
		///   Deserialize a serialized homogeneous 2D transformation matrix.
		///   Modified instance represents: Transformation matrix.
		/// </summary>
		/// <param name="serializedItemHandle">Handle of the serialized item.</param>
		// Token: 0x060005E2 RID: 1506 RVA: 0x00021330 File Offset: 0x0001F530
		public void DeserializeHomMat2d(HSerializedItem serializedItemHandle)
		{
			IntPtr proc = HalconAPI.PreCall(235);
			HalconAPI.Store(proc, 0, serializedItemHandle);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(serializedItemHandle);
		}

		/// <summary>
		///   Serialize a homogeneous 2D transformation matrix.
		///   Instance represents: Transformation matrix.
		/// </summary>
		/// <returns>Handle of the serialized item.</returns>
		// Token: 0x060005E3 RID: 1507 RVA: 0x0002137C File Offset: 0x0001F57C
		public HSerializedItem SerializeHomMat2d()
		{
			IntPtr proc = HalconAPI.PreCall(236);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HSerializedItem result;
			num = HSerializedItem.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Perform a bundle adjustment of an image mosaic.</summary>
		/// <param name="numImages">Number of different images that are used for the calibration.</param>
		/// <param name="referenceImage">Index of the reference image.</param>
		/// <param name="mappingSource">Indices of the source images of the transformations.</param>
		/// <param name="mappingDest">Indices of the target images of the transformations.</param>
		/// <param name="homMatrices2D">Array of 3x3 projective transformation matrices.</param>
		/// <param name="rows1">Row coordinates of corresponding points in the respective source images.</param>
		/// <param name="cols1">Column coordinates of corresponding points in the respective source images.</param>
		/// <param name="rows2">Row coordinates of corresponding points in the respective destination images.</param>
		/// <param name="cols2">Column coordinates of corresponding points in the respective destination images.</param>
		/// <param name="numCorrespondences">Number of point correspondences in the respective image pair.</param>
		/// <param name="transformation">Transformation class to be used. Default: "projective"</param>
		/// <param name="rows">Row coordinates of the points reconstructed by the bundle adjustment.</param>
		/// <param name="cols">Column coordinates of the points reconstructed by the bundle adjustment.</param>
		/// <param name="error">Average error per reconstructed point.</param>
		/// <returns>Array of 3x3 projective transformation matrices that determine the position of the images in the mosaic.</returns>
		// Token: 0x060005E4 RID: 1508 RVA: 0x000213CC File Offset: 0x0001F5CC
		public static HHomMat2D[] BundleAdjustMosaic(int numImages, int referenceImage, HTuple mappingSource, HTuple mappingDest, HHomMat2D[] homMatrices2D, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, HTuple numCorrespondences, string transformation, out HTuple rows, out HTuple cols, out HTuple error)
		{
			HTuple htuple = HData.ConcatArray(homMatrices2D);
			IntPtr proc = HalconAPI.PreCall(255);
			HalconAPI.StoreI(proc, 0, numImages);
			HalconAPI.StoreI(proc, 1, referenceImage);
			HalconAPI.Store(proc, 2, mappingSource);
			HalconAPI.Store(proc, 3, mappingDest);
			HalconAPI.Store(proc, 4, htuple);
			HalconAPI.Store(proc, 5, rows1);
			HalconAPI.Store(proc, 6, cols1);
			HalconAPI.Store(proc, 7, rows2);
			HalconAPI.Store(proc, 8, cols2);
			HalconAPI.Store(proc, 9, numCorrespondences);
			HalconAPI.StoreS(proc, 10, transformation);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(mappingSource);
			HalconAPI.UnpinTuple(mappingDest);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(numCorrespondences);
			HTuple data;
			num = HTuple.LoadNew(proc, 0, num, out data);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out rows);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out cols);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out error);
			HalconAPI.PostCall(proc, num);
			return HHomMat2D.SplitArray(data);
		}

		/// <summary>Perform a bundle adjustment of an image mosaic.</summary>
		/// <param name="numImages">Number of different images that are used for the calibration.</param>
		/// <param name="referenceImage">Index of the reference image.</param>
		/// <param name="mappingSource">Indices of the source images of the transformations.</param>
		/// <param name="mappingDest">Indices of the target images of the transformations.</param>
		/// <param name="homMatrices2D">Array of 3x3 projective transformation matrices.</param>
		/// <param name="rows1">Row coordinates of corresponding points in the respective source images.</param>
		/// <param name="cols1">Column coordinates of corresponding points in the respective source images.</param>
		/// <param name="rows2">Row coordinates of corresponding points in the respective destination images.</param>
		/// <param name="cols2">Column coordinates of corresponding points in the respective destination images.</param>
		/// <param name="numCorrespondences">Number of point correspondences in the respective image pair.</param>
		/// <param name="transformation">Transformation class to be used. Default: "projective"</param>
		/// <param name="rows">Row coordinates of the points reconstructed by the bundle adjustment.</param>
		/// <param name="cols">Column coordinates of the points reconstructed by the bundle adjustment.</param>
		/// <param name="error">Average error per reconstructed point.</param>
		/// <returns>Array of 3x3 projective transformation matrices that determine the position of the images in the mosaic.</returns>
		// Token: 0x060005E5 RID: 1509 RVA: 0x000214E4 File Offset: 0x0001F6E4
		public static HHomMat2D[] BundleAdjustMosaic(int numImages, int referenceImage, HTuple mappingSource, HTuple mappingDest, HHomMat2D[] homMatrices2D, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, HTuple numCorrespondences, string transformation, out HTuple rows, out HTuple cols, out double error)
		{
			HTuple htuple = HData.ConcatArray(homMatrices2D);
			IntPtr proc = HalconAPI.PreCall(255);
			HalconAPI.StoreI(proc, 0, numImages);
			HalconAPI.StoreI(proc, 1, referenceImage);
			HalconAPI.Store(proc, 2, mappingSource);
			HalconAPI.Store(proc, 3, mappingDest);
			HalconAPI.Store(proc, 4, htuple);
			HalconAPI.Store(proc, 5, rows1);
			HalconAPI.Store(proc, 6, cols1);
			HalconAPI.Store(proc, 7, rows2);
			HalconAPI.Store(proc, 8, cols2);
			HalconAPI.Store(proc, 9, numCorrespondences);
			HalconAPI.StoreS(proc, 10, transformation);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(mappingSource);
			HalconAPI.UnpinTuple(mappingDest);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(numCorrespondences);
			HTuple data;
			num = HTuple.LoadNew(proc, 0, num, out data);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out rows);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out cols);
			num = HalconAPI.LoadD(proc, 3, num, out error);
			HalconAPI.PostCall(proc, num);
			return HHomMat2D.SplitArray(data);
		}

		/// <summary>
		///   Compute a projective transformation matrix and the radial distortion coefficient between two images by finding correspondences between points based on known approximations of the projective transformation matrix and the radial distortion coefficient.
		///   Instance represents: Approximation of the homogeneous projective transformation matrix between the two images.
		/// </summary>
		/// <param name="image1">Input image 1.</param>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Input points in image 1 (row coordinate).</param>
		/// <param name="cols1">Input points in image 1 (column coordinate).</param>
		/// <param name="rows2">Input points in image 2 (row coordinate).</param>
		/// <param name="cols2">Input points in image 2 (column coordinate).</param>
		/// <param name="grayMatchMethod">Gray value match metric. Default: "ncc"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="kappaGuide">Approximation of the radial distortion coefficient in the two images.</param>
		/// <param name="distanceTolerance">Tolerance for the matching search window. Default: 20.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 0.7</param>
		/// <param name="estimationMethod">Algorithm for the computation of the projective transformation matrix. Default: "gold_standard"</param>
		/// <param name="distanceThreshold">Threshold for transformation consistency check. Default: 1</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="kappa">Computed radial distortion coefficient.</param>
		/// <param name="error">Root-Mean-Square transformation error.</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Computed homogeneous projective transformation matrix.</returns>
		// Token: 0x060005E6 RID: 1510 RVA: 0x000215FC File Offset: 0x0001F7FC
		public HHomMat2D ProjMatchPointsDistortionRansacGuided(HImage image1, HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, string grayMatchMethod, int maskSize, double kappaGuide, double distanceTolerance, HTuple matchThreshold, string estimationMethod, HTuple distanceThreshold, int randSeed, out double kappa, out double error, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(256);
			base.Store(proc, 6);
			HalconAPI.Store(proc, 1, image1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.StoreS(proc, 4, grayMatchMethod);
			HalconAPI.StoreI(proc, 5, maskSize);
			HalconAPI.StoreD(proc, 7, kappaGuide);
			HalconAPI.StoreD(proc, 8, distanceTolerance);
			HalconAPI.Store(proc, 9, matchThreshold);
			HalconAPI.StoreS(proc, 10, estimationMethod);
			HalconAPI.Store(proc, 11, distanceThreshold);
			HalconAPI.StoreI(proc, 12, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(matchThreshold);
			HalconAPI.UnpinTuple(distanceThreshold);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out kappa);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image1);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute a projective transformation matrix and the radial distortion coefficient between two images by finding correspondences between points based on known approximations of the projective transformation matrix and the radial distortion coefficient.
		///   Instance represents: Approximation of the homogeneous projective transformation matrix between the two images.
		/// </summary>
		/// <param name="image1">Input image 1.</param>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Input points in image 1 (row coordinate).</param>
		/// <param name="cols1">Input points in image 1 (column coordinate).</param>
		/// <param name="rows2">Input points in image 2 (row coordinate).</param>
		/// <param name="cols2">Input points in image 2 (column coordinate).</param>
		/// <param name="grayMatchMethod">Gray value match metric. Default: "ncc"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="kappaGuide">Approximation of the radial distortion coefficient in the two images.</param>
		/// <param name="distanceTolerance">Tolerance for the matching search window. Default: 20.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 0.7</param>
		/// <param name="estimationMethod">Algorithm for the computation of the projective transformation matrix. Default: "gold_standard"</param>
		/// <param name="distanceThreshold">Threshold for transformation consistency check. Default: 1</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="kappa">Computed radial distortion coefficient.</param>
		/// <param name="error">Root-Mean-Square transformation error.</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Computed homogeneous projective transformation matrix.</returns>
		// Token: 0x060005E7 RID: 1511 RVA: 0x0002174C File Offset: 0x0001F94C
		public HHomMat2D ProjMatchPointsDistortionRansacGuided(HImage image1, HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, string grayMatchMethod, int maskSize, double kappaGuide, double distanceTolerance, int matchThreshold, string estimationMethod, double distanceThreshold, int randSeed, out double kappa, out double error, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(256);
			base.Store(proc, 6);
			HalconAPI.Store(proc, 1, image1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.StoreS(proc, 4, grayMatchMethod);
			HalconAPI.StoreI(proc, 5, maskSize);
			HalconAPI.StoreD(proc, 7, kappaGuide);
			HalconAPI.StoreD(proc, 8, distanceTolerance);
			HalconAPI.StoreI(proc, 9, matchThreshold);
			HalconAPI.StoreS(proc, 10, estimationMethod);
			HalconAPI.StoreD(proc, 11, distanceThreshold);
			HalconAPI.StoreI(proc, 12, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out kappa);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image1);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute a projective transformation matrix between two images and the radial distortion coefficient by automatically finding correspondences between points.
		///   Modified instance represents: Computed homogeneous projective transformation matrix.
		/// </summary>
		/// <param name="image1">Input image 1.</param>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Input points in image 1 (row coordinate).</param>
		/// <param name="cols1">Input points in image 1 (column coordinate).</param>
		/// <param name="rows2">Input points in image 2 (row coordinate).</param>
		/// <param name="cols2">Input points in image 2 (column coordinate).</param>
		/// <param name="grayMatchMethod">Gray value match metric. Default: "ncc"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="rowMove">Average row coordinate offset of corresponding points. Default: 0</param>
		/// <param name="colMove">Average column coordinate offset of corresponding points. Default: 0</param>
		/// <param name="rowTolerance">Half height of matching search window. Default: 200</param>
		/// <param name="colTolerance">Half width of matching search window. Default: 200</param>
		/// <param name="rotation">Estimate of the relative rotation of the second image with respect to the first image. Default: 0.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 0.7</param>
		/// <param name="estimationMethod">Algorithm for the computation of the projective transformation matrix. Default: "gold_standard"</param>
		/// <param name="distanceThreshold">Threshold for the transformation consistency check. Default: 1</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="error">Root-Mean-Square transformation error.</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Computed radial distortion coefficient.</returns>
		// Token: 0x060005E8 RID: 1512 RVA: 0x00021890 File Offset: 0x0001FA90
		public double ProjMatchPointsDistortionRansac(HImage image1, HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, string grayMatchMethod, int maskSize, int rowMove, int colMove, int rowTolerance, int colTolerance, HTuple rotation, HTuple matchThreshold, string estimationMethod, HTuple distanceThreshold, int randSeed, out double error, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(257);
			HalconAPI.Store(proc, 1, image1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.StoreS(proc, 4, grayMatchMethod);
			HalconAPI.StoreI(proc, 5, maskSize);
			HalconAPI.StoreI(proc, 6, rowMove);
			HalconAPI.StoreI(proc, 7, colMove);
			HalconAPI.StoreI(proc, 8, rowTolerance);
			HalconAPI.StoreI(proc, 9, colTolerance);
			HalconAPI.Store(proc, 10, rotation);
			HalconAPI.Store(proc, 11, matchThreshold);
			HalconAPI.StoreS(proc, 12, estimationMethod);
			HalconAPI.Store(proc, 13, distanceThreshold);
			HalconAPI.StoreI(proc, 14, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(rotation);
			HalconAPI.UnpinTuple(matchThreshold);
			HalconAPI.UnpinTuple(distanceThreshold);
			num = base.Load(proc, 0, num);
			double result;
			num = HalconAPI.LoadD(proc, 1, num, out result);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image1);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute a projective transformation matrix between two images and the radial distortion coefficient by automatically finding correspondences between points.
		///   Modified instance represents: Computed homogeneous projective transformation matrix.
		/// </summary>
		/// <param name="image1">Input image 1.</param>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Input points in image 1 (row coordinate).</param>
		/// <param name="cols1">Input points in image 1 (column coordinate).</param>
		/// <param name="rows2">Input points in image 2 (row coordinate).</param>
		/// <param name="cols2">Input points in image 2 (column coordinate).</param>
		/// <param name="grayMatchMethod">Gray value match metric. Default: "ncc"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="rowMove">Average row coordinate offset of corresponding points. Default: 0</param>
		/// <param name="colMove">Average column coordinate offset of corresponding points. Default: 0</param>
		/// <param name="rowTolerance">Half height of matching search window. Default: 200</param>
		/// <param name="colTolerance">Half width of matching search window. Default: 200</param>
		/// <param name="rotation">Estimate of the relative rotation of the second image with respect to the first image. Default: 0.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 0.7</param>
		/// <param name="estimationMethod">Algorithm for the computation of the projective transformation matrix. Default: "gold_standard"</param>
		/// <param name="distanceThreshold">Threshold for the transformation consistency check. Default: 1</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="error">Root-Mean-Square transformation error.</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Computed radial distortion coefficient.</returns>
		// Token: 0x060005E9 RID: 1513 RVA: 0x000219F8 File Offset: 0x0001FBF8
		public double ProjMatchPointsDistortionRansac(HImage image1, HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, string grayMatchMethod, int maskSize, int rowMove, int colMove, int rowTolerance, int colTolerance, double rotation, int matchThreshold, string estimationMethod, double distanceThreshold, int randSeed, out double error, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(257);
			HalconAPI.Store(proc, 1, image1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.StoreS(proc, 4, grayMatchMethod);
			HalconAPI.StoreI(proc, 5, maskSize);
			HalconAPI.StoreI(proc, 6, rowMove);
			HalconAPI.StoreI(proc, 7, colMove);
			HalconAPI.StoreI(proc, 8, rowTolerance);
			HalconAPI.StoreI(proc, 9, colTolerance);
			HalconAPI.StoreD(proc, 10, rotation);
			HalconAPI.StoreI(proc, 11, matchThreshold);
			HalconAPI.StoreS(proc, 12, estimationMethod);
			HalconAPI.StoreD(proc, 13, distanceThreshold);
			HalconAPI.StoreI(proc, 14, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			num = base.Load(proc, 0, num);
			double result;
			num = HalconAPI.LoadD(proc, 1, num, out result);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image1);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute a projective transformation matrix between two images by finding correspondences between points based on a known approximation of the projective transformation matrix.
		///   Instance represents: Approximation of the Homogeneous projective transformation matrix between the two images.
		/// </summary>
		/// <param name="image1">Input image 1.</param>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Row coordinates of characteristic points in image 1.</param>
		/// <param name="cols1">Column coordinates of characteristic points in image 1.</param>
		/// <param name="rows2">Row coordinates of characteristic points in image 2.</param>
		/// <param name="cols2">Column coordinates of characteristic points in image 2.</param>
		/// <param name="grayMatchMethod">Gray value comparison metric. Default: "ssd"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="distanceTolerance">Tolerance for the matching search window. Default: 20.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 10</param>
		/// <param name="estimationMethod">Transformation matrix estimation algorithm. Default: "normalized_dlt"</param>
		/// <param name="distanceThreshold">Threshold for transformation consistency check. Default: 0.2</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Homogeneous projective transformation matrix.</returns>
		// Token: 0x060005EA RID: 1514 RVA: 0x00021B48 File Offset: 0x0001FD48
		public HHomMat2D ProjMatchPointsRansacGuided(HImage image1, HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, string grayMatchMethod, int maskSize, double distanceTolerance, HTuple matchThreshold, string estimationMethod, double distanceThreshold, int randSeed, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(258);
			base.Store(proc, 6);
			HalconAPI.Store(proc, 1, image1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.StoreS(proc, 4, grayMatchMethod);
			HalconAPI.StoreI(proc, 5, maskSize);
			HalconAPI.StoreD(proc, 7, distanceTolerance);
			HalconAPI.Store(proc, 8, matchThreshold);
			HalconAPI.StoreS(proc, 9, estimationMethod);
			HalconAPI.StoreD(proc, 10, distanceThreshold);
			HalconAPI.StoreI(proc, 11, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(matchThreshold);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image1);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute a projective transformation matrix between two images by finding correspondences between points based on a known approximation of the projective transformation matrix.
		///   Instance represents: Approximation of the Homogeneous projective transformation matrix between the two images.
		/// </summary>
		/// <param name="image1">Input image 1.</param>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Row coordinates of characteristic points in image 1.</param>
		/// <param name="cols1">Column coordinates of characteristic points in image 1.</param>
		/// <param name="rows2">Row coordinates of characteristic points in image 2.</param>
		/// <param name="cols2">Column coordinates of characteristic points in image 2.</param>
		/// <param name="grayMatchMethod">Gray value comparison metric. Default: "ssd"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="distanceTolerance">Tolerance for the matching search window. Default: 20.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 10</param>
		/// <param name="estimationMethod">Transformation matrix estimation algorithm. Default: "normalized_dlt"</param>
		/// <param name="distanceThreshold">Threshold for transformation consistency check. Default: 0.2</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Homogeneous projective transformation matrix.</returns>
		// Token: 0x060005EB RID: 1515 RVA: 0x00021C64 File Offset: 0x0001FE64
		public HHomMat2D ProjMatchPointsRansacGuided(HImage image1, HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, string grayMatchMethod, int maskSize, double distanceTolerance, int matchThreshold, string estimationMethod, double distanceThreshold, int randSeed, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(258);
			base.Store(proc, 6);
			HalconAPI.Store(proc, 1, image1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.StoreS(proc, 4, grayMatchMethod);
			HalconAPI.StoreI(proc, 5, maskSize);
			HalconAPI.StoreD(proc, 7, distanceTolerance);
			HalconAPI.StoreI(proc, 8, matchThreshold);
			HalconAPI.StoreS(proc, 9, estimationMethod);
			HalconAPI.StoreD(proc, 10, distanceThreshold);
			HalconAPI.StoreI(proc, 11, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image1);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute a projective transformation matrix between two images by finding correspondences between points.
		///   Modified instance represents: Homogeneous projective transformation matrix.
		/// </summary>
		/// <param name="image1">Input image 1.</param>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Row coordinates of characteristic points in image 1.</param>
		/// <param name="cols1">Column coordinates of characteristic points in image 1.</param>
		/// <param name="rows2">Row coordinates of characteristic points in image 2.</param>
		/// <param name="cols2">Column coordinates of characteristic points in image 2.</param>
		/// <param name="grayMatchMethod">Gray value comparison metric. Default: "ssd"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="rowMove">Average row coordinate shift. Default: 0</param>
		/// <param name="colMove">Average column coordinate shift. Default: 0</param>
		/// <param name="rowTolerance">Half height of matching search window. Default: 256</param>
		/// <param name="colTolerance">Half width of matching search window. Default: 256</param>
		/// <param name="rotation">Range of rotation angles. Default: 0.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 10</param>
		/// <param name="estimationMethod">Transformation matrix estimation algorithm. Default: "normalized_dlt"</param>
		/// <param name="distanceThreshold">Threshold for transformation consistency check. Default: 0.2</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Indices of matched input points in image 1.</returns>
		// Token: 0x060005EC RID: 1516 RVA: 0x00021D78 File Offset: 0x0001FF78
		public HTuple ProjMatchPointsRansac(HImage image1, HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, string grayMatchMethod, int maskSize, int rowMove, int colMove, int rowTolerance, int colTolerance, HTuple rotation, HTuple matchThreshold, string estimationMethod, double distanceThreshold, int randSeed, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(259);
			HalconAPI.Store(proc, 1, image1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.StoreS(proc, 4, grayMatchMethod);
			HalconAPI.StoreI(proc, 5, maskSize);
			HalconAPI.StoreI(proc, 6, rowMove);
			HalconAPI.StoreI(proc, 7, colMove);
			HalconAPI.StoreI(proc, 8, rowTolerance);
			HalconAPI.StoreI(proc, 9, colTolerance);
			HalconAPI.Store(proc, 10, rotation);
			HalconAPI.Store(proc, 11, matchThreshold);
			HalconAPI.StoreS(proc, 12, estimationMethod);
			HalconAPI.StoreD(proc, 13, distanceThreshold);
			HalconAPI.StoreI(proc, 14, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(rotation);
			HalconAPI.UnpinTuple(matchThreshold);
			num = base.Load(proc, 0, num);
			HTuple result;
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out result);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image1);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute a projective transformation matrix between two images by finding correspondences between points.
		///   Modified instance represents: Homogeneous projective transformation matrix.
		/// </summary>
		/// <param name="image1">Input image 1.</param>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Row coordinates of characteristic points in image 1.</param>
		/// <param name="cols1">Column coordinates of characteristic points in image 1.</param>
		/// <param name="rows2">Row coordinates of characteristic points in image 2.</param>
		/// <param name="cols2">Column coordinates of characteristic points in image 2.</param>
		/// <param name="grayMatchMethod">Gray value comparison metric. Default: "ssd"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="rowMove">Average row coordinate shift. Default: 0</param>
		/// <param name="colMove">Average column coordinate shift. Default: 0</param>
		/// <param name="rowTolerance">Half height of matching search window. Default: 256</param>
		/// <param name="colTolerance">Half width of matching search window. Default: 256</param>
		/// <param name="rotation">Range of rotation angles. Default: 0.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 10</param>
		/// <param name="estimationMethod">Transformation matrix estimation algorithm. Default: "normalized_dlt"</param>
		/// <param name="distanceThreshold">Threshold for transformation consistency check. Default: 0.2</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Indices of matched input points in image 1.</returns>
		// Token: 0x060005ED RID: 1517 RVA: 0x00021EB0 File Offset: 0x000200B0
		public HTuple ProjMatchPointsRansac(HImage image1, HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, string grayMatchMethod, int maskSize, int rowMove, int colMove, int rowTolerance, int colTolerance, double rotation, int matchThreshold, string estimationMethod, double distanceThreshold, int randSeed, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(259);
			HalconAPI.Store(proc, 1, image1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.StoreS(proc, 4, grayMatchMethod);
			HalconAPI.StoreI(proc, 5, maskSize);
			HalconAPI.StoreI(proc, 6, rowMove);
			HalconAPI.StoreI(proc, 7, colMove);
			HalconAPI.StoreI(proc, 8, rowTolerance);
			HalconAPI.StoreI(proc, 9, colTolerance);
			HalconAPI.StoreD(proc, 10, rotation);
			HalconAPI.StoreI(proc, 11, matchThreshold);
			HalconAPI.StoreS(proc, 12, estimationMethod);
			HalconAPI.StoreD(proc, 13, distanceThreshold);
			HalconAPI.StoreI(proc, 14, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			num = base.Load(proc, 0, num);
			HTuple result;
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out result);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image1);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute a projective transformation matrix and the radial distortion coefficient using given image point correspondences.
		///   Modified instance represents: Homogeneous projective transformation matrix.
		/// </summary>
		/// <param name="points1Row">Input points in image 1 (row coordinate).</param>
		/// <param name="points1Col">Input points in image 1 (column coordinate).</param>
		/// <param name="points2Row">Input points in image 2 (row coordinate).</param>
		/// <param name="points2Col">Input points in image 2 (column coordinate).</param>
		/// <param name="covRR1">Row coordinate variance of the points in image 1. Default: []</param>
		/// <param name="covRC1">Covariance of the points in image 1. Default: []</param>
		/// <param name="covCC1">Column coordinate variance of the points in image 1. Default: []</param>
		/// <param name="covRR2">Row coordinate variance of the points in image 2. Default: []</param>
		/// <param name="covRC2">Covariance of the points in image 2. Default: []</param>
		/// <param name="covCC2">Column coordinate variance of the points in image 2. Default: []</param>
		/// <param name="imageWidth">Width of the images from which the points were extracted.</param>
		/// <param name="imageHeight">Height of the images from which the points were extracted.</param>
		/// <param name="method">Estimation algorithm. Default: "gold_standard"</param>
		/// <param name="error">Root-Mean-Square transformation error.</param>
		/// <returns>Computed radial distortion coefficient.</returns>
		// Token: 0x060005EE RID: 1518 RVA: 0x00021FDC File Offset: 0x000201DC
		public double VectorToProjHomMat2dDistortion(HTuple points1Row, HTuple points1Col, HTuple points2Row, HTuple points2Col, HTuple covRR1, HTuple covRC1, HTuple covCC1, HTuple covRR2, HTuple covRC2, HTuple covCC2, int imageWidth, int imageHeight, string method, out double error)
		{
			IntPtr proc = HalconAPI.PreCall(260);
			HalconAPI.Store(proc, 0, points1Row);
			HalconAPI.Store(proc, 1, points1Col);
			HalconAPI.Store(proc, 2, points2Row);
			HalconAPI.Store(proc, 3, points2Col);
			HalconAPI.Store(proc, 4, covRR1);
			HalconAPI.Store(proc, 5, covRC1);
			HalconAPI.Store(proc, 6, covCC1);
			HalconAPI.Store(proc, 7, covRR2);
			HalconAPI.Store(proc, 8, covRC2);
			HalconAPI.Store(proc, 9, covCC2);
			HalconAPI.StoreI(proc, 10, imageWidth);
			HalconAPI.StoreI(proc, 11, imageHeight);
			HalconAPI.StoreS(proc, 12, method);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(points1Row);
			HalconAPI.UnpinTuple(points1Col);
			HalconAPI.UnpinTuple(points2Row);
			HalconAPI.UnpinTuple(points2Col);
			HalconAPI.UnpinTuple(covRR1);
			HalconAPI.UnpinTuple(covRC1);
			HalconAPI.UnpinTuple(covCC1);
			HalconAPI.UnpinTuple(covRR2);
			HalconAPI.UnpinTuple(covRC2);
			HalconAPI.UnpinTuple(covCC2);
			num = base.Load(proc, 0, num);
			double result;
			num = HalconAPI.LoadD(proc, 1, num, out result);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute a homogeneous transformation matrix using given point correspondences.
		///   Modified instance represents: Homogeneous projective transformation matrix.
		/// </summary>
		/// <param name="px">Input points 1 (x coordinate).</param>
		/// <param name="py">Input points 1 (y coordinate).</param>
		/// <param name="pw">Input points 1 (w coordinate).</param>
		/// <param name="qx">Input points 2 (x coordinate).</param>
		/// <param name="qy">Input points 2 (y coordinate).</param>
		/// <param name="qw">Input points 2 (w coordinate).</param>
		/// <param name="method">Estimation algorithm. Default: "normalized_dlt"</param>
		// Token: 0x060005EF RID: 1519 RVA: 0x000220FC File Offset: 0x000202FC
		public void HomVectorToProjHomMat2d(HTuple px, HTuple py, HTuple pw, HTuple qx, HTuple qy, HTuple qw, string method)
		{
			IntPtr proc = HalconAPI.PreCall(261);
			HalconAPI.Store(proc, 0, px);
			HalconAPI.Store(proc, 1, py);
			HalconAPI.Store(proc, 2, pw);
			HalconAPI.Store(proc, 3, qx);
			HalconAPI.Store(proc, 4, qy);
			HalconAPI.Store(proc, 5, qw);
			HalconAPI.StoreS(proc, 6, method);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(px);
			HalconAPI.UnpinTuple(py);
			HalconAPI.UnpinTuple(pw);
			HalconAPI.UnpinTuple(qx);
			HalconAPI.UnpinTuple(qy);
			HalconAPI.UnpinTuple(qw);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Compute a projective transformation matrix using given point correspondences.
		///   Modified instance represents: Homogeneous projective transformation matrix.
		/// </summary>
		/// <param name="px">Input points in image 1 (row coordinate).</param>
		/// <param name="py">Input points in image 1 (column coordinate).</param>
		/// <param name="qx">Input points in image 2 (row coordinate).</param>
		/// <param name="qy">Input points in image 2 (column coordinate).</param>
		/// <param name="method">Estimation algorithm. Default: "normalized_dlt"</param>
		/// <param name="covXX1">Row coordinate variance of the points in image 1. Default: []</param>
		/// <param name="covYY1">Column coordinate variance of the points in image 1. Default: []</param>
		/// <param name="covXY1">Covariance of the points in image 1. Default: []</param>
		/// <param name="covXX2">Row coordinate variance of the points in image 2. Default: []</param>
		/// <param name="covYY2">Column coordinate variance of the points in image 2. Default: []</param>
		/// <param name="covXY2">Covariance of the points in image 2. Default: []</param>
		/// <returns>9x9 covariance matrix of the projective transformation matrix.</returns>
		// Token: 0x060005F0 RID: 1520 RVA: 0x000221A0 File Offset: 0x000203A0
		public HTuple VectorToProjHomMat2d(HTuple px, HTuple py, HTuple qx, HTuple qy, string method, HTuple covXX1, HTuple covYY1, HTuple covXY1, HTuple covXX2, HTuple covYY2, HTuple covXY2)
		{
			IntPtr proc = HalconAPI.PreCall(262);
			HalconAPI.Store(proc, 0, px);
			HalconAPI.Store(proc, 1, py);
			HalconAPI.Store(proc, 2, qx);
			HalconAPI.Store(proc, 3, qy);
			HalconAPI.StoreS(proc, 4, method);
			HalconAPI.Store(proc, 5, covXX1);
			HalconAPI.Store(proc, 6, covYY1);
			HalconAPI.Store(proc, 7, covXY1);
			HalconAPI.Store(proc, 8, covXX2);
			HalconAPI.Store(proc, 9, covYY2);
			HalconAPI.Store(proc, 10, covXY2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(px);
			HalconAPI.UnpinTuple(py);
			HalconAPI.UnpinTuple(qx);
			HalconAPI.UnpinTuple(qy);
			HalconAPI.UnpinTuple(covXX1);
			HalconAPI.UnpinTuple(covYY1);
			HalconAPI.UnpinTuple(covXY1);
			HalconAPI.UnpinTuple(covXX2);
			HalconAPI.UnpinTuple(covYY2);
			HalconAPI.UnpinTuple(covXY2);
			num = base.Load(proc, 0, num);
			HTuple result;
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the affine transformation parameters from a homogeneous 2D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="sy">Scaling factor along the y direction.</param>
		/// <param name="phi">Rotation angle.</param>
		/// <param name="theta">Slant angle.</param>
		/// <param name="tx">Translation along the x direction.</param>
		/// <param name="ty">Translation along the y direction.</param>
		/// <returns>Scaling factor along the x direction.</returns>
		// Token: 0x060005F1 RID: 1521 RVA: 0x00022298 File Offset: 0x00020498
		public double HomMat2dToAffinePar(out double sy, out double phi, out double theta, out double tx, out double ty)
		{
			IntPtr proc = HalconAPI.PreCall(263);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out sy);
			num = HalconAPI.LoadD(proc, 2, num, out phi);
			num = HalconAPI.LoadD(proc, 3, num, out theta);
			num = HalconAPI.LoadD(proc, 4, num, out tx);
			num = HalconAPI.LoadD(proc, 5, num, out ty);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute a rigid affine transformation from points and angles.
		///   Modified instance represents: Output transformation matrix.
		/// </summary>
		/// <param name="row1">Row coordinate of the original point.</param>
		/// <param name="column1">Column coordinate of the original point.</param>
		/// <param name="angle1">Angle of the original point.</param>
		/// <param name="row2">Row coordinate of the transformed point.</param>
		/// <param name="column2">Column coordinate of the transformed point.</param>
		/// <param name="angle2">Angle of the transformed point.</param>
		// Token: 0x060005F2 RID: 1522 RVA: 0x00022344 File Offset: 0x00020544
		public void VectorAngleToRigid(HTuple row1, HTuple column1, HTuple angle1, HTuple row2, HTuple column2, HTuple angle2)
		{
			IntPtr proc = HalconAPI.PreCall(264);
			HalconAPI.Store(proc, 0, row1);
			HalconAPI.Store(proc, 1, column1);
			HalconAPI.Store(proc, 2, angle1);
			HalconAPI.Store(proc, 3, row2);
			HalconAPI.Store(proc, 4, column2);
			HalconAPI.Store(proc, 5, angle2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row1);
			HalconAPI.UnpinTuple(column1);
			HalconAPI.UnpinTuple(angle1);
			HalconAPI.UnpinTuple(row2);
			HalconAPI.UnpinTuple(column2);
			HalconAPI.UnpinTuple(angle2);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Compute a rigid affine transformation from points and angles.
		///   Modified instance represents: Output transformation matrix.
		/// </summary>
		/// <param name="row1">Row coordinate of the original point.</param>
		/// <param name="column1">Column coordinate of the original point.</param>
		/// <param name="angle1">Angle of the original point.</param>
		/// <param name="row2">Row coordinate of the transformed point.</param>
		/// <param name="column2">Column coordinate of the transformed point.</param>
		/// <param name="angle2">Angle of the transformed point.</param>
		// Token: 0x060005F3 RID: 1523 RVA: 0x000223DC File Offset: 0x000205DC
		public void VectorAngleToRigid(double row1, double column1, double angle1, double row2, double column2, double angle2)
		{
			IntPtr proc = HalconAPI.PreCall(264);
			HalconAPI.StoreD(proc, 0, row1);
			HalconAPI.StoreD(proc, 1, column1);
			HalconAPI.StoreD(proc, 2, angle1);
			HalconAPI.StoreD(proc, 3, row2);
			HalconAPI.StoreD(proc, 4, column2);
			HalconAPI.StoreD(proc, 5, angle2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Approximate an affine transformation from point-to-line correspondences.
		///   Modified instance represents: Output transformation matrix.
		/// </summary>
		/// <param name="transformationType">Type of the transformation to compute. Default: "rigid"</param>
		/// <param name="px">X coordinates of the original points.</param>
		/// <param name="py">Y coordinates of the original points.</param>
		/// <param name="l1x">X coordinates of the first point on the corresponding line.</param>
		/// <param name="l1y">Y coordinates of the first point on the corresponding line.</param>
		/// <param name="l2x">X coordinates of the second point on the corresponding line.</param>
		/// <param name="l2y">Y coordinates of the second point on the corresponding line.</param>
		// Token: 0x060005F4 RID: 1524 RVA: 0x00022450 File Offset: 0x00020650
		public void PointLineToHomMat2d(string transformationType, HTuple px, HTuple py, HTuple l1x, HTuple l1y, HTuple l2x, HTuple l2y)
		{
			IntPtr proc = HalconAPI.PreCall(265);
			HalconAPI.StoreS(proc, 0, transformationType);
			HalconAPI.Store(proc, 1, px);
			HalconAPI.Store(proc, 2, py);
			HalconAPI.Store(proc, 3, l1x);
			HalconAPI.Store(proc, 4, l1y);
			HalconAPI.Store(proc, 5, l2x);
			HalconAPI.Store(proc, 6, l2y);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(px);
			HalconAPI.UnpinTuple(py);
			HalconAPI.UnpinTuple(l1x);
			HalconAPI.UnpinTuple(l1y);
			HalconAPI.UnpinTuple(l2x);
			HalconAPI.UnpinTuple(l2y);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Approximate a rigid affine transformation from point correspondences.
		///   Modified instance represents: Output transformation matrix.
		/// </summary>
		/// <param name="px">X coordinates of the original points.</param>
		/// <param name="py">Y coordinates of the original points.</param>
		/// <param name="qx">X coordinates of the transformed points.</param>
		/// <param name="qy">Y coordinates of the transformed points.</param>
		// Token: 0x060005F5 RID: 1525 RVA: 0x000224F4 File Offset: 0x000206F4
		public void VectorToRigid(HTuple px, HTuple py, HTuple qx, HTuple qy)
		{
			IntPtr proc = HalconAPI.PreCall(266);
			HalconAPI.Store(proc, 0, px);
			HalconAPI.Store(proc, 1, py);
			HalconAPI.Store(proc, 2, qx);
			HalconAPI.Store(proc, 3, qy);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(px);
			HalconAPI.UnpinTuple(py);
			HalconAPI.UnpinTuple(qx);
			HalconAPI.UnpinTuple(qy);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Approximate an similarity transformation from point correspondences.
		///   Modified instance represents: Output transformation matrix.
		/// </summary>
		/// <param name="px">X coordinates of the original points.</param>
		/// <param name="py">Y coordinates of the original points.</param>
		/// <param name="qx">X coordinates of the transformed points.</param>
		/// <param name="qy">Y coordinates of the transformed points.</param>
		// Token: 0x060005F6 RID: 1526 RVA: 0x0002256C File Offset: 0x0002076C
		public void VectorToSimilarity(HTuple px, HTuple py, HTuple qx, HTuple qy)
		{
			IntPtr proc = HalconAPI.PreCall(267);
			HalconAPI.Store(proc, 0, px);
			HalconAPI.Store(proc, 1, py);
			HalconAPI.Store(proc, 2, qx);
			HalconAPI.Store(proc, 3, qy);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(px);
			HalconAPI.UnpinTuple(py);
			HalconAPI.UnpinTuple(qx);
			HalconAPI.UnpinTuple(qy);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Approximate an anisotropic similarity transformation from point correspondences.
		///   Modified instance represents: Output transformation matrix.
		/// </summary>
		/// <param name="px">X coordinates of the original points.</param>
		/// <param name="py">Y coordinates of the original points.</param>
		/// <param name="qx">X coordinates of the transformed points.</param>
		/// <param name="qy">Y coordinates of the transformed points.</param>
		// Token: 0x060005F7 RID: 1527 RVA: 0x000225E4 File Offset: 0x000207E4
		public void VectorToAniso(HTuple px, HTuple py, HTuple qx, HTuple qy)
		{
			IntPtr proc = HalconAPI.PreCall(268);
			HalconAPI.Store(proc, 0, px);
			HalconAPI.Store(proc, 1, py);
			HalconAPI.Store(proc, 2, qx);
			HalconAPI.Store(proc, 3, qy);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(px);
			HalconAPI.UnpinTuple(py);
			HalconAPI.UnpinTuple(qx);
			HalconAPI.UnpinTuple(qy);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Approximate an affine transformation from point correspondences.
		///   Modified instance represents: Output transformation matrix.
		/// </summary>
		/// <param name="px">X coordinates of the original points.</param>
		/// <param name="py">Y coordinates of the original points.</param>
		/// <param name="qx">X coordinates of the transformed points.</param>
		/// <param name="qy">Y coordinates of the transformed points.</param>
		// Token: 0x060005F8 RID: 1528 RVA: 0x0002265C File Offset: 0x0002085C
		public void VectorToHomMat2d(HTuple px, HTuple py, HTuple qx, HTuple qy)
		{
			IntPtr proc = HalconAPI.PreCall(269);
			HalconAPI.Store(proc, 0, px);
			HalconAPI.Store(proc, 1, py);
			HalconAPI.Store(proc, 2, qx);
			HalconAPI.Store(proc, 3, qy);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(px);
			HalconAPI.UnpinTuple(py);
			HalconAPI.UnpinTuple(qx);
			HalconAPI.UnpinTuple(qy);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Project pixel coordinates using a homogeneous projective transformation matrix.
		///   Instance represents: Homogeneous projective transformation matrix.
		/// </summary>
		/// <param name="row">Input pixel(s) (row coordinate). Default: 64</param>
		/// <param name="col">Input pixel(s) (column coordinate). Default: 64</param>
		/// <param name="rowTrans">Output pixel(s) (row coordinate).</param>
		/// <param name="colTrans">Output pixel(s) (column coordinate).</param>
		// Token: 0x060005F9 RID: 1529 RVA: 0x000226D4 File Offset: 0x000208D4
		public void ProjectiveTransPixel(HTuple row, HTuple col, out HTuple rowTrans, out HTuple colTrans)
		{
			IntPtr proc = HalconAPI.PreCall(270);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, row);
			HalconAPI.Store(proc, 2, col);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(col);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out rowTrans);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out colTrans);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Project pixel coordinates using a homogeneous projective transformation matrix.
		///   Instance represents: Homogeneous projective transformation matrix.
		/// </summary>
		/// <param name="row">Input pixel(s) (row coordinate). Default: 64</param>
		/// <param name="col">Input pixel(s) (column coordinate). Default: 64</param>
		/// <param name="rowTrans">Output pixel(s) (row coordinate).</param>
		/// <param name="colTrans">Output pixel(s) (column coordinate).</param>
		// Token: 0x060005FA RID: 1530 RVA: 0x00022754 File Offset: 0x00020954
		public void ProjectiveTransPixel(double row, double col, out double rowTrans, out double colTrans)
		{
			IntPtr proc = HalconAPI.PreCall(270);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, row);
			HalconAPI.StoreD(proc, 2, col);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			num = HalconAPI.LoadD(proc, 0, num, out rowTrans);
			num = HalconAPI.LoadD(proc, 1, num, out colTrans);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Project a homogeneous 2D point using a projective transformation matrix.
		///   Instance represents: Homogeneous projective transformation matrix.
		/// </summary>
		/// <param name="px">Input point (x coordinate).</param>
		/// <param name="py">Input point (y coordinate).</param>
		/// <param name="pw">Input point (w coordinate).</param>
		/// <param name="qy">Output point (y coordinate).</param>
		/// <param name="qw">Output point (w coordinate).</param>
		/// <returns>Output point (x coordinate).</returns>
		// Token: 0x060005FB RID: 1531 RVA: 0x000227C4 File Offset: 0x000209C4
		public HTuple ProjectiveTransPoint2d(HTuple px, HTuple py, HTuple pw, out HTuple qy, out HTuple qw)
		{
			IntPtr proc = HalconAPI.PreCall(271);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, px);
			HalconAPI.Store(proc, 2, py);
			HalconAPI.Store(proc, 3, pw);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(px);
			HalconAPI.UnpinTuple(py);
			HalconAPI.UnpinTuple(pw);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out qy);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out qw);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Project a homogeneous 2D point using a projective transformation matrix.
		///   Instance represents: Homogeneous projective transformation matrix.
		/// </summary>
		/// <param name="px">Input point (x coordinate).</param>
		/// <param name="py">Input point (y coordinate).</param>
		/// <param name="pw">Input point (w coordinate).</param>
		/// <param name="qy">Output point (y coordinate).</param>
		/// <param name="qw">Output point (w coordinate).</param>
		/// <returns>Output point (x coordinate).</returns>
		// Token: 0x060005FC RID: 1532 RVA: 0x00022868 File Offset: 0x00020A68
		public double ProjectiveTransPoint2d(double px, double py, double pw, out double qy, out double qw)
		{
			IntPtr proc = HalconAPI.PreCall(271);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, px);
			HalconAPI.StoreD(proc, 2, py);
			HalconAPI.StoreD(proc, 3, pw);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out qy);
			num = HalconAPI.LoadD(proc, 2, num, out qw);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Apply an arbitrary affine 2D transformation to pixel coordinates.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="row">Input pixel(s) (row coordinate). Default: 64</param>
		/// <param name="col">Input pixel(s) (column coordinate). Default: 64</param>
		/// <param name="rowTrans">Output pixel(s) (row coordinate).</param>
		/// <param name="colTrans">Output pixel(s) (column coordinate).</param>
		// Token: 0x060005FD RID: 1533 RVA: 0x000228F4 File Offset: 0x00020AF4
		public void AffineTransPixel(HTuple row, HTuple col, out HTuple rowTrans, out HTuple colTrans)
		{
			IntPtr proc = HalconAPI.PreCall(272);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, row);
			HalconAPI.Store(proc, 2, col);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(col);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out rowTrans);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out colTrans);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Apply an arbitrary affine 2D transformation to pixel coordinates.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="row">Input pixel(s) (row coordinate). Default: 64</param>
		/// <param name="col">Input pixel(s) (column coordinate). Default: 64</param>
		/// <param name="rowTrans">Output pixel(s) (row coordinate).</param>
		/// <param name="colTrans">Output pixel(s) (column coordinate).</param>
		// Token: 0x060005FE RID: 1534 RVA: 0x00022974 File Offset: 0x00020B74
		public void AffineTransPixel(double row, double col, out double rowTrans, out double colTrans)
		{
			IntPtr proc = HalconAPI.PreCall(272);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, row);
			HalconAPI.StoreD(proc, 2, col);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			num = HalconAPI.LoadD(proc, 0, num, out rowTrans);
			num = HalconAPI.LoadD(proc, 1, num, out colTrans);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Apply an arbitrary affine 2D transformation to points.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="px">Input point(s) (x or row coordinate). Default: 64</param>
		/// <param name="py">Input point(s) (y or column coordinate). Default: 64</param>
		/// <param name="qy">Output point(s) (y or column coordinate).</param>
		/// <returns>Output point(s) (x or row coordinate).</returns>
		// Token: 0x060005FF RID: 1535 RVA: 0x000229E4 File Offset: 0x00020BE4
		public HTuple AffineTransPoint2d(HTuple px, HTuple py, out HTuple qy)
		{
			IntPtr proc = HalconAPI.PreCall(273);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, px);
			HalconAPI.Store(proc, 2, py);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(px);
			HalconAPI.UnpinTuple(py);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out qy);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Apply an arbitrary affine 2D transformation to points.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="px">Input point(s) (x or row coordinate). Default: 64</param>
		/// <param name="py">Input point(s) (y or column coordinate). Default: 64</param>
		/// <param name="qy">Output point(s) (y or column coordinate).</param>
		/// <returns>Output point(s) (x or row coordinate).</returns>
		// Token: 0x06000600 RID: 1536 RVA: 0x00022A64 File Offset: 0x00020C64
		public double AffineTransPoint2d(double px, double py, out double qy)
		{
			IntPtr proc = HalconAPI.PreCall(273);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, px);
			HalconAPI.StoreD(proc, 2, py);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out qy);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the determinant of a homogeneous 2D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <returns>Determinant of the input matrix.</returns>
		// Token: 0x06000601 RID: 1537 RVA: 0x00022AD4 File Offset: 0x00020CD4
		public double HomMat2dDeterminant()
		{
			IntPtr proc = HalconAPI.PreCall(274);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transpose a homogeneous 2D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000602 RID: 1538 RVA: 0x00022B24 File Offset: 0x00020D24
		public HHomMat2D HomMat2dTranspose()
		{
			IntPtr proc = HalconAPI.PreCall(275);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Invert a homogeneous 2D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000603 RID: 1539 RVA: 0x00022B74 File Offset: 0x00020D74
		public HHomMat2D HomMat2dInvert()
		{
			IntPtr proc = HalconAPI.PreCall(276);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Multiply two homogeneous 2D transformation matrices.
		///   Instance represents: Left input transformation matrix.
		/// </summary>
		/// <param name="homMat2DRight">Right input transformation matrix.</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000604 RID: 1540 RVA: 0x00022BC4 File Offset: 0x00020DC4
		public HHomMat2D HomMat2dCompose(HHomMat2D homMat2DRight)
		{
			IntPtr proc = HalconAPI.PreCall(277);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, homMat2DRight);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(homMat2DRight);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a reflection to a homogeneous 2D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="px">Point that defines the axis (x coordinate). Default: 16</param>
		/// <param name="py">Point that defines the axis (y coordinate). Default: 32</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000605 RID: 1541 RVA: 0x00022C2C File Offset: 0x00020E2C
		public HHomMat2D HomMat2dReflectLocal(HTuple px, HTuple py)
		{
			IntPtr proc = HalconAPI.PreCall(278);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, px);
			HalconAPI.Store(proc, 2, py);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(px);
			HalconAPI.UnpinTuple(py);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a reflection to a homogeneous 2D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="px">Point that defines the axis (x coordinate). Default: 16</param>
		/// <param name="py">Point that defines the axis (y coordinate). Default: 32</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000606 RID: 1542 RVA: 0x00022C98 File Offset: 0x00020E98
		public HHomMat2D HomMat2dReflectLocal(double px, double py)
		{
			IntPtr proc = HalconAPI.PreCall(278);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, px);
			HalconAPI.StoreD(proc, 2, py);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a reflection to a homogeneous 2D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="px">First point of the axis (x coordinate). Default: 0</param>
		/// <param name="py">First point of the axis (y coordinate). Default: 0</param>
		/// <param name="qx">Second point of the axis (x coordinate). Default: 16</param>
		/// <param name="qy">Second point of the axis (y coordinate). Default: 32</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000607 RID: 1543 RVA: 0x00022CF8 File Offset: 0x00020EF8
		public HHomMat2D HomMat2dReflect(HTuple px, HTuple py, HTuple qx, HTuple qy)
		{
			IntPtr proc = HalconAPI.PreCall(279);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, px);
			HalconAPI.Store(proc, 2, py);
			HalconAPI.Store(proc, 3, qx);
			HalconAPI.Store(proc, 4, qy);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(px);
			HalconAPI.UnpinTuple(py);
			HalconAPI.UnpinTuple(qx);
			HalconAPI.UnpinTuple(qy);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a reflection to a homogeneous 2D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="px">First point of the axis (x coordinate). Default: 0</param>
		/// <param name="py">First point of the axis (y coordinate). Default: 0</param>
		/// <param name="qx">Second point of the axis (x coordinate). Default: 16</param>
		/// <param name="qy">Second point of the axis (y coordinate). Default: 32</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000608 RID: 1544 RVA: 0x00022D80 File Offset: 0x00020F80
		public HHomMat2D HomMat2dReflect(double px, double py, double qx, double qy)
		{
			IntPtr proc = HalconAPI.PreCall(279);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, px);
			HalconAPI.StoreD(proc, 2, py);
			HalconAPI.StoreD(proc, 3, qx);
			HalconAPI.StoreD(proc, 4, qy);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a slant to a homogeneous 2D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="theta">Slant angle. Default: 0.78</param>
		/// <param name="axis">Coordinate axis that is slanted. Default: "x"</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000609 RID: 1545 RVA: 0x00022DF0 File Offset: 0x00020FF0
		public HHomMat2D HomMat2dSlantLocal(HTuple theta, string axis)
		{
			IntPtr proc = HalconAPI.PreCall(280);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, theta);
			HalconAPI.StoreS(proc, 2, axis);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(theta);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a slant to a homogeneous 2D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="theta">Slant angle. Default: 0.78</param>
		/// <param name="axis">Coordinate axis that is slanted. Default: "x"</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x0600060A RID: 1546 RVA: 0x00022E54 File Offset: 0x00021054
		public HHomMat2D HomMat2dSlantLocal(double theta, string axis)
		{
			IntPtr proc = HalconAPI.PreCall(280);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, theta);
			HalconAPI.StoreS(proc, 2, axis);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a slant to a homogeneous 2D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="theta">Slant angle. Default: 0.78</param>
		/// <param name="axis">Coordinate axis that is slanted. Default: "x"</param>
		/// <param name="px">Fixed point of the transformation (x coordinate). Default: 0</param>
		/// <param name="py">Fixed point of the transformation (y coordinate). Default: 0</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x0600060B RID: 1547 RVA: 0x00022EB4 File Offset: 0x000210B4
		public HHomMat2D HomMat2dSlant(HTuple theta, string axis, HTuple px, HTuple py)
		{
			IntPtr proc = HalconAPI.PreCall(281);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, theta);
			HalconAPI.StoreS(proc, 2, axis);
			HalconAPI.Store(proc, 3, px);
			HalconAPI.Store(proc, 4, py);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(theta);
			HalconAPI.UnpinTuple(px);
			HalconAPI.UnpinTuple(py);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a slant to a homogeneous 2D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="theta">Slant angle. Default: 0.78</param>
		/// <param name="axis">Coordinate axis that is slanted. Default: "x"</param>
		/// <param name="px">Fixed point of the transformation (x coordinate). Default: 0</param>
		/// <param name="py">Fixed point of the transformation (y coordinate). Default: 0</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x0600060C RID: 1548 RVA: 0x00022F38 File Offset: 0x00021138
		public HHomMat2D HomMat2dSlant(double theta, string axis, double px, double py)
		{
			IntPtr proc = HalconAPI.PreCall(281);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, theta);
			HalconAPI.StoreS(proc, 2, axis);
			HalconAPI.StoreD(proc, 3, px);
			HalconAPI.StoreD(proc, 4, py);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a rotation to a homogeneous 2D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="phi">Rotation angle. Default: 0.78</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x0600060D RID: 1549 RVA: 0x00022FA8 File Offset: 0x000211A8
		public HHomMat2D HomMat2dRotateLocal(HTuple phi)
		{
			IntPtr proc = HalconAPI.PreCall(282);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, phi);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(phi);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a rotation to a homogeneous 2D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="phi">Rotation angle. Default: 0.78</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x0600060E RID: 1550 RVA: 0x00023004 File Offset: 0x00021204
		public HHomMat2D HomMat2dRotateLocal(double phi)
		{
			IntPtr proc = HalconAPI.PreCall(282);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, phi);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a rotation to a homogeneous 2D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="phi">Rotation angle. Default: 0.78</param>
		/// <param name="px">Fixed point of the transformation (x coordinate). Default: 0</param>
		/// <param name="py">Fixed point of the transformation (y coordinate). Default: 0</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x0600060F RID: 1551 RVA: 0x0002305C File Offset: 0x0002125C
		public HHomMat2D HomMat2dRotate(HTuple phi, HTuple px, HTuple py)
		{
			IntPtr proc = HalconAPI.PreCall(283);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, phi);
			HalconAPI.Store(proc, 2, px);
			HalconAPI.Store(proc, 3, py);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(phi);
			HalconAPI.UnpinTuple(px);
			HalconAPI.UnpinTuple(py);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a rotation to a homogeneous 2D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="phi">Rotation angle. Default: 0.78</param>
		/// <param name="px">Fixed point of the transformation (x coordinate). Default: 0</param>
		/// <param name="py">Fixed point of the transformation (y coordinate). Default: 0</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000610 RID: 1552 RVA: 0x000230D4 File Offset: 0x000212D4
		public HHomMat2D HomMat2dRotate(double phi, double px, double py)
		{
			IntPtr proc = HalconAPI.PreCall(283);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, phi);
			HalconAPI.StoreD(proc, 2, px);
			HalconAPI.StoreD(proc, 3, py);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a scaling to a homogeneous 2D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="sx">Scale factor along the x-axis. Default: 2</param>
		/// <param name="sy">Scale factor along the y-axis. Default: 2</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000611 RID: 1553 RVA: 0x0002313C File Offset: 0x0002133C
		public HHomMat2D HomMat2dScaleLocal(HTuple sx, HTuple sy)
		{
			IntPtr proc = HalconAPI.PreCall(284);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, sx);
			HalconAPI.Store(proc, 2, sy);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(sx);
			HalconAPI.UnpinTuple(sy);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a scaling to a homogeneous 2D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="sx">Scale factor along the x-axis. Default: 2</param>
		/// <param name="sy">Scale factor along the y-axis. Default: 2</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000612 RID: 1554 RVA: 0x000231A8 File Offset: 0x000213A8
		public HHomMat2D HomMat2dScaleLocal(double sx, double sy)
		{
			IntPtr proc = HalconAPI.PreCall(284);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, sx);
			HalconAPI.StoreD(proc, 2, sy);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a scaling to a homogeneous 2D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="sx">Scale factor along the x-axis. Default: 2</param>
		/// <param name="sy">Scale factor along the y-axis. Default: 2</param>
		/// <param name="px">Fixed point of the transformation (x coordinate). Default: 0</param>
		/// <param name="py">Fixed point of the transformation (y coordinate). Default: 0</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000613 RID: 1555 RVA: 0x00023208 File Offset: 0x00021408
		public HHomMat2D HomMat2dScale(HTuple sx, HTuple sy, HTuple px, HTuple py)
		{
			IntPtr proc = HalconAPI.PreCall(285);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, sx);
			HalconAPI.Store(proc, 2, sy);
			HalconAPI.Store(proc, 3, px);
			HalconAPI.Store(proc, 4, py);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(sx);
			HalconAPI.UnpinTuple(sy);
			HalconAPI.UnpinTuple(px);
			HalconAPI.UnpinTuple(py);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a scaling to a homogeneous 2D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="sx">Scale factor along the x-axis. Default: 2</param>
		/// <param name="sy">Scale factor along the y-axis. Default: 2</param>
		/// <param name="px">Fixed point of the transformation (x coordinate). Default: 0</param>
		/// <param name="py">Fixed point of the transformation (y coordinate). Default: 0</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000614 RID: 1556 RVA: 0x00023290 File Offset: 0x00021490
		public HHomMat2D HomMat2dScale(double sx, double sy, double px, double py)
		{
			IntPtr proc = HalconAPI.PreCall(285);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, sx);
			HalconAPI.StoreD(proc, 2, sy);
			HalconAPI.StoreD(proc, 3, px);
			HalconAPI.StoreD(proc, 4, py);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a translation to a homogeneous 2D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="tx">Translation along the x-axis. Default: 64</param>
		/// <param name="ty">Translation along the y-axis. Default: 64</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000615 RID: 1557 RVA: 0x00023300 File Offset: 0x00021500
		public HHomMat2D HomMat2dTranslateLocal(HTuple tx, HTuple ty)
		{
			IntPtr proc = HalconAPI.PreCall(286);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, tx);
			HalconAPI.Store(proc, 2, ty);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(tx);
			HalconAPI.UnpinTuple(ty);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a translation to a homogeneous 2D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="tx">Translation along the x-axis. Default: 64</param>
		/// <param name="ty">Translation along the y-axis. Default: 64</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000616 RID: 1558 RVA: 0x0002336C File Offset: 0x0002156C
		public HHomMat2D HomMat2dTranslateLocal(double tx, double ty)
		{
			IntPtr proc = HalconAPI.PreCall(286);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, tx);
			HalconAPI.StoreD(proc, 2, ty);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a translation to a homogeneous 2D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="tx">Translation along the x-axis. Default: 64</param>
		/// <param name="ty">Translation along the y-axis. Default: 64</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000617 RID: 1559 RVA: 0x000233CC File Offset: 0x000215CC
		public HHomMat2D HomMat2dTranslate(HTuple tx, HTuple ty)
		{
			IntPtr proc = HalconAPI.PreCall(287);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, tx);
			HalconAPI.Store(proc, 2, ty);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(tx);
			HalconAPI.UnpinTuple(ty);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a translation to a homogeneous 2D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="tx">Translation along the x-axis. Default: 64</param>
		/// <param name="ty">Translation along the y-axis. Default: 64</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000618 RID: 1560 RVA: 0x00023438 File Offset: 0x00021638
		public HHomMat2D HomMat2dTranslate(double tx, double ty)
		{
			IntPtr proc = HalconAPI.PreCall(287);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, tx);
			HalconAPI.StoreD(proc, 2, ty);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Generate the homogeneous transformation matrix of the identical 2D transformation.
		///   Modified instance represents: Transformation matrix.
		/// </summary>
		// Token: 0x06000619 RID: 1561 RVA: 0x00023498 File Offset: 0x00021698
		public void HomMat2dIdentity()
		{
			IntPtr proc = HalconAPI.PreCall(288);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Compute the projective 3d reconstruction of points based on the fundamental matrix.
		///   Instance represents: Fundamental matrix.
		/// </summary>
		/// <param name="rows1">Input points in image 1 (row coordinate).</param>
		/// <param name="cols1">Input points in image 1 (column coordinate).</param>
		/// <param name="rows2">Input points in image 2 (row coordinate).</param>
		/// <param name="cols2">Input points in image 2 (column coordinate).</param>
		/// <param name="covRR1">Row coordinate variance of the points in image 1. Default: []</param>
		/// <param name="covRC1">Covariance of the points in image 1. Default: []</param>
		/// <param name="covCC1">Column coordinate variance of the points in image 1. Default: []</param>
		/// <param name="covRR2">Row coordinate variance of the points in image 2. Default: []</param>
		/// <param name="covRC2">Covariance of the points in image 2. Default: []</param>
		/// <param name="covCC2">Column coordinate variance of the points in image 2. Default: []</param>
		/// <param name="covFMat">9x9 covariance matrix of the fundamental matrix. Default: []</param>
		/// <param name="x">X coordinates of the reconstructed points in projective 3D space.</param>
		/// <param name="y">Y coordinates of the reconstructed points in projective 3D space.</param>
		/// <param name="z">Z coordinates of the reconstructed points in projective 3D space.</param>
		/// <param name="w">W coordinates of the reconstructed points in projective 3D space.</param>
		/// <param name="covXYZW">Covariance matrices of the reconstructed points.</param>
		// Token: 0x0600061A RID: 1562 RVA: 0x000234D8 File Offset: 0x000216D8
		public void Reconst3dFromFundamentalMatrix(HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, HTuple covRR1, HTuple covRC1, HTuple covCC1, HTuple covRR2, HTuple covRC2, HTuple covCC2, HTuple covFMat, out HTuple x, out HTuple y, out HTuple z, out HTuple w, out HTuple covXYZW)
		{
			IntPtr proc = HalconAPI.PreCall(350);
			base.Store(proc, 10);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.Store(proc, 4, covRR1);
			HalconAPI.Store(proc, 5, covRC1);
			HalconAPI.Store(proc, 6, covCC1);
			HalconAPI.Store(proc, 7, covRR2);
			HalconAPI.Store(proc, 8, covRC2);
			HalconAPI.Store(proc, 9, covCC2);
			HalconAPI.Store(proc, 11, covFMat);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(covRR1);
			HalconAPI.UnpinTuple(covRC1);
			HalconAPI.UnpinTuple(covCC1);
			HalconAPI.UnpinTuple(covRR2);
			HalconAPI.UnpinTuple(covRC2);
			HalconAPI.UnpinTuple(covCC2);
			HalconAPI.UnpinTuple(covFMat);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out x);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out y);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out z);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out w);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out covXYZW);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Compute the projective 3d reconstruction of points based on the fundamental matrix.
		///   Instance represents: Fundamental matrix.
		/// </summary>
		/// <param name="rows1">Input points in image 1 (row coordinate).</param>
		/// <param name="cols1">Input points in image 1 (column coordinate).</param>
		/// <param name="rows2">Input points in image 2 (row coordinate).</param>
		/// <param name="cols2">Input points in image 2 (column coordinate).</param>
		/// <param name="covRR1">Row coordinate variance of the points in image 1. Default: []</param>
		/// <param name="covRC1">Covariance of the points in image 1. Default: []</param>
		/// <param name="covCC1">Column coordinate variance of the points in image 1. Default: []</param>
		/// <param name="covRR2">Row coordinate variance of the points in image 2. Default: []</param>
		/// <param name="covRC2">Covariance of the points in image 2. Default: []</param>
		/// <param name="covCC2">Column coordinate variance of the points in image 2. Default: []</param>
		/// <param name="covFMat">9x9 covariance matrix of the fundamental matrix. Default: []</param>
		/// <param name="x">X coordinates of the reconstructed points in projective 3D space.</param>
		/// <param name="y">Y coordinates of the reconstructed points in projective 3D space.</param>
		/// <param name="z">Z coordinates of the reconstructed points in projective 3D space.</param>
		/// <param name="w">W coordinates of the reconstructed points in projective 3D space.</param>
		/// <param name="covXYZW">Covariance matrices of the reconstructed points.</param>
		// Token: 0x0600061B RID: 1563 RVA: 0x00023624 File Offset: 0x00021824
		public void Reconst3dFromFundamentalMatrix(double rows1, double cols1, double rows2, double cols2, double covRR1, double covRC1, double covCC1, double covRR2, double covRC2, double covCC2, HTuple covFMat, out double x, out double y, out double z, out double w, out double covXYZW)
		{
			IntPtr proc = HalconAPI.PreCall(350);
			base.Store(proc, 10);
			HalconAPI.StoreD(proc, 0, rows1);
			HalconAPI.StoreD(proc, 1, cols1);
			HalconAPI.StoreD(proc, 2, rows2);
			HalconAPI.StoreD(proc, 3, cols2);
			HalconAPI.StoreD(proc, 4, covRR1);
			HalconAPI.StoreD(proc, 5, covRC1);
			HalconAPI.StoreD(proc, 6, covCC1);
			HalconAPI.StoreD(proc, 7, covRR2);
			HalconAPI.StoreD(proc, 8, covRC2);
			HalconAPI.StoreD(proc, 9, covCC2);
			HalconAPI.Store(proc, 11, covFMat);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(covFMat);
			num = HalconAPI.LoadD(proc, 0, num, out x);
			num = HalconAPI.LoadD(proc, 1, num, out y);
			num = HalconAPI.LoadD(proc, 2, num, out z);
			num = HalconAPI.LoadD(proc, 3, num, out w);
			num = HalconAPI.LoadD(proc, 4, num, out covXYZW);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Compute the projective rectification of weakly calibrated binocular stereo images.
		///   Instance represents: Fundamental matrix.
		/// </summary>
		/// <param name="map2">Image coding the rectification of the 2. image.</param>
		/// <param name="covFMat">9x9 covariance matrix of the fundamental matrix. Default: []</param>
		/// <param name="width1">Width of the 1. image. Default: 512</param>
		/// <param name="height1">Height of the 1. image. Default: 512</param>
		/// <param name="width2">Width of the 2. image. Default: 512</param>
		/// <param name="height2">Height of the 2. image. Default: 512</param>
		/// <param name="subSampling">Subsampling factor. Default: 1</param>
		/// <param name="mapping">Type of mapping. Default: "no_map"</param>
		/// <param name="covFMatRect">9x9 covariance matrix of the rectified fundamental matrix.</param>
		/// <param name="h1">Projective transformation of the 1. image.</param>
		/// <param name="h2">Projective transformation of the 2. image.</param>
		/// <returns>Image coding the rectification of the 1. image.</returns>
		// Token: 0x0600061C RID: 1564 RVA: 0x00023728 File Offset: 0x00021928
		public HImage GenBinocularProjRectification(out HImage map2, HTuple covFMat, int width1, int height1, int width2, int height2, HTuple subSampling, string mapping, out HTuple covFMatRect, out HHomMat2D h1, out HHomMat2D h2)
		{
			IntPtr proc = HalconAPI.PreCall(351);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, covFMat);
			HalconAPI.StoreI(proc, 2, width1);
			HalconAPI.StoreI(proc, 3, height1);
			HalconAPI.StoreI(proc, 4, width2);
			HalconAPI.StoreI(proc, 5, height2);
			HalconAPI.Store(proc, 6, subSampling);
			HalconAPI.StoreS(proc, 7, mapping);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(covFMat);
			HalconAPI.UnpinTuple(subSampling);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out map2);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out covFMatRect);
			num = HHomMat2D.LoadNew(proc, 1, num, out h1);
			num = HHomMat2D.LoadNew(proc, 2, num, out h2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the projective rectification of weakly calibrated binocular stereo images.
		///   Instance represents: Fundamental matrix.
		/// </summary>
		/// <param name="map2">Image coding the rectification of the 2. image.</param>
		/// <param name="covFMat">9x9 covariance matrix of the fundamental matrix. Default: []</param>
		/// <param name="width1">Width of the 1. image. Default: 512</param>
		/// <param name="height1">Height of the 1. image. Default: 512</param>
		/// <param name="width2">Width of the 2. image. Default: 512</param>
		/// <param name="height2">Height of the 2. image. Default: 512</param>
		/// <param name="subSampling">Subsampling factor. Default: 1</param>
		/// <param name="mapping">Type of mapping. Default: "no_map"</param>
		/// <param name="covFMatRect">9x9 covariance matrix of the rectified fundamental matrix.</param>
		/// <param name="h1">Projective transformation of the 1. image.</param>
		/// <param name="h2">Projective transformation of the 2. image.</param>
		/// <returns>Image coding the rectification of the 1. image.</returns>
		// Token: 0x0600061D RID: 1565 RVA: 0x0002380C File Offset: 0x00021A0C
		public HImage GenBinocularProjRectification(out HImage map2, HTuple covFMat, int width1, int height1, int width2, int height2, int subSampling, string mapping, out HTuple covFMatRect, out HHomMat2D h1, out HHomMat2D h2)
		{
			IntPtr proc = HalconAPI.PreCall(351);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, covFMat);
			HalconAPI.StoreI(proc, 2, width1);
			HalconAPI.StoreI(proc, 3, height1);
			HalconAPI.StoreI(proc, 4, width2);
			HalconAPI.StoreI(proc, 5, height2);
			HalconAPI.StoreI(proc, 6, subSampling);
			HalconAPI.StoreS(proc, 7, mapping);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(covFMat);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out map2);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out covFMatRect);
			num = HHomMat2D.LoadNew(proc, 1, num, out h1);
			num = HHomMat2D.LoadNew(proc, 2, num, out h2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the fundamental matrix and the radial distortion coefficient given a set of image point correspondences and reconstruct 3D points.
		///   Modified instance represents: Computed fundamental matrix.
		/// </summary>
		/// <param name="rows1">Input points in image 1 (row coordinate).</param>
		/// <param name="cols1">Input points in image 1 (column coordinate).</param>
		/// <param name="rows2">Input points in image 2 (row coordinate).</param>
		/// <param name="cols2">Input points in image 2 (column coordinate).</param>
		/// <param name="covRR1">Row coordinate variance of the points in image 1. Default: []</param>
		/// <param name="covRC1">Covariance of the points in image 1. Default: []</param>
		/// <param name="covCC1">Column coordinate variance of the points in image 1. Default: []</param>
		/// <param name="covRR2">Row coordinate variance of the points in image 2. Default: []</param>
		/// <param name="covRC2">Covariance of the points in image 2. Default: []</param>
		/// <param name="covCC2">Column coordinate variance of the points in image 2. Default: []</param>
		/// <param name="imageWidth">Width of the images from which the points were extracted.</param>
		/// <param name="imageHeight">Height of the images from which the points were extracted.</param>
		/// <param name="method">Estimation algorithm. Default: "gold_standard"</param>
		/// <param name="error">Root-Mean-Square epipolar distance error.</param>
		/// <param name="x">X coordinates of the reconstructed points in projective 3D space.</param>
		/// <param name="y">Y coordinates of the reconstructed points in projective 3D space.</param>
		/// <param name="z">Z coordinates of the reconstructed points in projective 3D space.</param>
		/// <param name="w">W coordinates of the reconstructed points in projective 3D space.</param>
		/// <returns>Computed radial distortion coefficient.</returns>
		// Token: 0x0600061E RID: 1566 RVA: 0x000238EC File Offset: 0x00021AEC
		public double VectorToFundamentalMatrixDistortion(HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, HTuple covRR1, HTuple covRC1, HTuple covCC1, HTuple covRR2, HTuple covRC2, HTuple covCC2, int imageWidth, int imageHeight, string method, out double error, out HTuple x, out HTuple y, out HTuple z, out HTuple w)
		{
			IntPtr proc = HalconAPI.PreCall(352);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.Store(proc, 4, covRR1);
			HalconAPI.Store(proc, 5, covRC1);
			HalconAPI.Store(proc, 6, covCC1);
			HalconAPI.Store(proc, 7, covRR2);
			HalconAPI.Store(proc, 8, covRC2);
			HalconAPI.Store(proc, 9, covCC2);
			HalconAPI.StoreI(proc, 10, imageWidth);
			HalconAPI.StoreI(proc, 11, imageHeight);
			HalconAPI.StoreS(proc, 12, method);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(covRR1);
			HalconAPI.UnpinTuple(covRC1);
			HalconAPI.UnpinTuple(covCC1);
			HalconAPI.UnpinTuple(covRR2);
			HalconAPI.UnpinTuple(covRC2);
			HalconAPI.UnpinTuple(covCC2);
			num = base.Load(proc, 0, num);
			double result;
			num = HalconAPI.LoadD(proc, 1, num, out result);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out x);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out y);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out z);
			num = HTuple.LoadNew(proc, 6, HTupleType.DOUBLE, num, out w);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the fundamental matrix from the relative orientation of two cameras.
		///   Modified instance represents: Computed fundamental matrix.
		/// </summary>
		/// <param name="relPose">Relative orientation of the cameras (3D pose).</param>
		/// <param name="covRelPose">6x6 covariance matrix of relative pose. Default: []</param>
		/// <param name="camPar1">Parameters of the 1. camera.</param>
		/// <param name="camPar2">Parameters of the 2. camera.</param>
		/// <returns>9x9 covariance matrix of the fundamental matrix.</returns>
		// Token: 0x0600061F RID: 1567 RVA: 0x00023A5C File Offset: 0x00021C5C
		public HTuple RelPoseToFundamentalMatrix(HPose relPose, HTuple covRelPose, HCamPar camPar1, HCamPar camPar2)
		{
			IntPtr proc = HalconAPI.PreCall(353);
			HalconAPI.Store(proc, 0, relPose);
			HalconAPI.Store(proc, 1, covRelPose);
			HalconAPI.Store(proc, 2, camPar1);
			HalconAPI.Store(proc, 3, camPar2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(relPose);
			HalconAPI.UnpinTuple(covRelPose);
			HalconAPI.UnpinTuple(camPar1);
			HalconAPI.UnpinTuple(camPar2);
			num = base.Load(proc, 0, num);
			HTuple result;
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the fundamental matrix from an essential matrix.
		///   Instance represents: Essential matrix.
		/// </summary>
		/// <param name="covEMat">9x9 covariance matrix of the essential matrix. Default: []</param>
		/// <param name="camMat1">Camera matrix of the 1. camera.</param>
		/// <param name="camMat2">Camera matrix of the 2. camera.</param>
		/// <param name="covFMat">9x9 covariance matrix of the fundamental matrix.</param>
		/// <returns>Computed fundamental matrix.</returns>
		// Token: 0x06000620 RID: 1568 RVA: 0x00023B08 File Offset: 0x00021D08
		public HHomMat2D EssentialToFundamentalMatrix(HTuple covEMat, HHomMat2D camMat1, HHomMat2D camMat2, out HTuple covFMat)
		{
			IntPtr proc = HalconAPI.PreCall(354);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, covEMat);
			HalconAPI.Store(proc, 2, camMat1);
			HalconAPI.Store(proc, 3, camMat2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(covEMat);
			HalconAPI.UnpinTuple(camMat1);
			HalconAPI.UnpinTuple(camMat2);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out covFMat);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the essential matrix given image point correspondences and known camera matrices and reconstruct 3D points.
		///   Instance represents: Camera matrix of the 1st camera.
		/// </summary>
		/// <param name="rows1">Input points in image 1 (row coordinate).</param>
		/// <param name="cols1">Input points in image 1 (column coordinate).</param>
		/// <param name="rows2">Input points in image 2 (row coordinate).</param>
		/// <param name="cols2">Input points in image 2 (column coordinate).</param>
		/// <param name="covRR1">Row coordinate variance of the points in image 1. Default: []</param>
		/// <param name="covRC1">Covariance of the points in image 1. Default: []</param>
		/// <param name="covCC1">Column coordinate variance of the points in image 1. Default: []</param>
		/// <param name="covRR2">Row coordinate variance of the points in image 2. Default: []</param>
		/// <param name="covRC2">Covariance of the points in image 2. Default: []</param>
		/// <param name="covCC2">Column coordinate variance of the points in image 2. Default: []</param>
		/// <param name="camMat2">Camera matrix of the 2nd camera.</param>
		/// <param name="method">Algorithm for the computation of the essential matrix and for special camera orientations. Default: "normalized_dlt"</param>
		/// <param name="covEMat">9x9 covariance matrix of the essential matrix.</param>
		/// <param name="error">Root-Mean-Square of the epipolar distance error.</param>
		/// <param name="x">X coordinates of the reconstructed 3D points.</param>
		/// <param name="y">Y coordinates of the reconstructed 3D points.</param>
		/// <param name="z">Z coordinates of the reconstructed 3D points.</param>
		/// <param name="covXYZ">Covariance matrices of the reconstructed 3D points.</param>
		/// <returns>Computed essential matrix.</returns>
		// Token: 0x06000621 RID: 1569 RVA: 0x00023BA8 File Offset: 0x00021DA8
		public HHomMat2D VectorToEssentialMatrix(HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, HTuple covRR1, HTuple covRC1, HTuple covCC1, HTuple covRR2, HTuple covRC2, HTuple covCC2, HHomMat2D camMat2, string method, out HTuple covEMat, out HTuple error, out HTuple x, out HTuple y, out HTuple z, out HTuple covXYZ)
		{
			IntPtr proc = HalconAPI.PreCall(356);
			base.Store(proc, 10);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.Store(proc, 4, covRR1);
			HalconAPI.Store(proc, 5, covRC1);
			HalconAPI.Store(proc, 6, covCC1);
			HalconAPI.Store(proc, 7, covRR2);
			HalconAPI.Store(proc, 8, covRC2);
			HalconAPI.Store(proc, 9, covCC2);
			HalconAPI.Store(proc, 11, camMat2);
			HalconAPI.StoreS(proc, 12, method);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(covRR1);
			HalconAPI.UnpinTuple(covRC1);
			HalconAPI.UnpinTuple(covCC1);
			HalconAPI.UnpinTuple(covRR2);
			HalconAPI.UnpinTuple(covRC2);
			HalconAPI.UnpinTuple(covCC2);
			HalconAPI.UnpinTuple(camMat2);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out covEMat);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out x);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out y);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out z);
			num = HTuple.LoadNew(proc, 6, HTupleType.DOUBLE, num, out covXYZ);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the essential matrix given image point correspondences and known camera matrices and reconstruct 3D points.
		///   Instance represents: Camera matrix of the 1st camera.
		/// </summary>
		/// <param name="rows1">Input points in image 1 (row coordinate).</param>
		/// <param name="cols1">Input points in image 1 (column coordinate).</param>
		/// <param name="rows2">Input points in image 2 (row coordinate).</param>
		/// <param name="cols2">Input points in image 2 (column coordinate).</param>
		/// <param name="covRR1">Row coordinate variance of the points in image 1. Default: []</param>
		/// <param name="covRC1">Covariance of the points in image 1. Default: []</param>
		/// <param name="covCC1">Column coordinate variance of the points in image 1. Default: []</param>
		/// <param name="covRR2">Row coordinate variance of the points in image 2. Default: []</param>
		/// <param name="covRC2">Covariance of the points in image 2. Default: []</param>
		/// <param name="covCC2">Column coordinate variance of the points in image 2. Default: []</param>
		/// <param name="camMat2">Camera matrix of the 2nd camera.</param>
		/// <param name="method">Algorithm for the computation of the essential matrix and for special camera orientations. Default: "normalized_dlt"</param>
		/// <param name="covEMat">9x9 covariance matrix of the essential matrix.</param>
		/// <param name="error">Root-Mean-Square of the epipolar distance error.</param>
		/// <param name="x">X coordinates of the reconstructed 3D points.</param>
		/// <param name="y">Y coordinates of the reconstructed 3D points.</param>
		/// <param name="z">Z coordinates of the reconstructed 3D points.</param>
		/// <param name="covXYZ">Covariance matrices of the reconstructed 3D points.</param>
		/// <returns>Computed essential matrix.</returns>
		// Token: 0x06000622 RID: 1570 RVA: 0x00023D30 File Offset: 0x00021F30
		public HHomMat2D VectorToEssentialMatrix(HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, HTuple covRR1, HTuple covRC1, HTuple covCC1, HTuple covRR2, HTuple covRC2, HTuple covCC2, HHomMat2D camMat2, string method, out HTuple covEMat, out double error, out HTuple x, out HTuple y, out HTuple z, out HTuple covXYZ)
		{
			IntPtr proc = HalconAPI.PreCall(356);
			base.Store(proc, 10);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.Store(proc, 4, covRR1);
			HalconAPI.Store(proc, 5, covRC1);
			HalconAPI.Store(proc, 6, covCC1);
			HalconAPI.Store(proc, 7, covRR2);
			HalconAPI.Store(proc, 8, covRC2);
			HalconAPI.Store(proc, 9, covCC2);
			HalconAPI.Store(proc, 11, camMat2);
			HalconAPI.StoreS(proc, 12, method);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(covRR1);
			HalconAPI.UnpinTuple(covRC1);
			HalconAPI.UnpinTuple(covCC1);
			HalconAPI.UnpinTuple(covRR2);
			HalconAPI.UnpinTuple(covRC2);
			HalconAPI.UnpinTuple(covCC2);
			HalconAPI.UnpinTuple(camMat2);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out covEMat);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out x);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out y);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out z);
			num = HTuple.LoadNew(proc, 6, HTupleType.DOUBLE, num, out covXYZ);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the fundamental matrix given a set of image point correspondences and reconstruct 3D points.
		///   Modified instance represents: Computed fundamental matrix.
		/// </summary>
		/// <param name="rows1">Input points in image 1 (row coordinate).</param>
		/// <param name="cols1">Input points in image 1 (column coordinate).</param>
		/// <param name="rows2">Input points in image 2 (row coordinate).</param>
		/// <param name="cols2">Input points in image 2 (column coordinate).</param>
		/// <param name="covRR1">Row coordinate variance of the points in image 1. Default: []</param>
		/// <param name="covRC1">Covariance of the points in image 1. Default: []</param>
		/// <param name="covCC1">Column coordinate variance of the points in image 1. Default: []</param>
		/// <param name="covRR2">Row coordinate variance of the points in image 2. Default: []</param>
		/// <param name="covRC2">Covariance of the points in image 2. Default: []</param>
		/// <param name="covCC2">Column coordinate variance of the points in image 2. Default: []</param>
		/// <param name="method">Estimation algorithm. Default: "normalized_dlt"</param>
		/// <param name="error">Root-Mean-Square of the epipolar distance error.</param>
		/// <param name="x">X coordinates of the reconstructed points in projective 3D space.</param>
		/// <param name="y">Y coordinates of the reconstructed points in projective 3D space.</param>
		/// <param name="z">Z coordinates of the reconstructed points in projective 3D space.</param>
		/// <param name="w">W coordinates of the reconstructed points in projective 3D space.</param>
		/// <param name="covXYZW">Covariance matrices of the reconstructed 3D points.</param>
		/// <returns>9x9 covariance matrix of the fundamental matrix.</returns>
		// Token: 0x06000623 RID: 1571 RVA: 0x00023EB8 File Offset: 0x000220B8
		public HTuple VectorToFundamentalMatrix(HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, HTuple covRR1, HTuple covRC1, HTuple covCC1, HTuple covRR2, HTuple covRC2, HTuple covCC2, string method, out double error, out HTuple x, out HTuple y, out HTuple z, out HTuple w, out HTuple covXYZW)
		{
			IntPtr proc = HalconAPI.PreCall(357);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.Store(proc, 4, covRR1);
			HalconAPI.Store(proc, 5, covRC1);
			HalconAPI.Store(proc, 6, covCC1);
			HalconAPI.Store(proc, 7, covRR2);
			HalconAPI.Store(proc, 8, covRC2);
			HalconAPI.Store(proc, 9, covCC2);
			HalconAPI.StoreS(proc, 10, method);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			HalconAPI.InitOCT(proc, 7);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(covRR1);
			HalconAPI.UnpinTuple(covRC1);
			HalconAPI.UnpinTuple(covCC1);
			HalconAPI.UnpinTuple(covRR2);
			HalconAPI.UnpinTuple(covRC2);
			HalconAPI.UnpinTuple(covCC2);
			num = base.Load(proc, 0, num);
			HTuple result;
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out result);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out x);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out y);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out z);
			num = HTuple.LoadNew(proc, 6, HTupleType.DOUBLE, num, out w);
			num = HTuple.LoadNew(proc, 7, HTupleType.DOUBLE, num, out covXYZW);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the fundamental matrix and the radial distortion coefficient for a pair of stereo images by automatically finding correspondences between image points.
		///   Modified instance represents: Computed fundamental matrix.
		/// </summary>
		/// <param name="image1">Input image 1.</param>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Input points in image 1 (row coordinate).</param>
		/// <param name="cols1">Input points in image 1 (column coordinate).</param>
		/// <param name="rows2">Input points in image 2 (row coordinate).</param>
		/// <param name="cols2">Input points in image 2 (column coordinate).</param>
		/// <param name="grayMatchMethod">Gray value match metric. Default: "ncc"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="rowMove">Average row coordinate offset of corresponding points. Default: 0</param>
		/// <param name="colMove">Average column coordinate offset of corresponding points. Default: 0</param>
		/// <param name="rowTolerance">Half height of matching search window. Default: 200</param>
		/// <param name="colTolerance">Half width of matching search window. Default: 200</param>
		/// <param name="rotation">Estimate of the relative rotation of the second image with respect to the first image. Default: 0.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 0.7</param>
		/// <param name="estimationMethod">Algorithm for the computation of the fundamental matrix and for special camera orientations. Default: "gold_standard"</param>
		/// <param name="distanceThreshold">Maximal deviation of a point from its epipolar line. Default: 1</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="error">Root-Mean-Square epipolar distance error.</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Computed radial distortion coefficient.</returns>
		// Token: 0x06000624 RID: 1572 RVA: 0x00024028 File Offset: 0x00022228
		public double MatchFundamentalMatrixDistortionRansac(HImage image1, HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, string grayMatchMethod, int maskSize, int rowMove, int colMove, int rowTolerance, int colTolerance, HTuple rotation, HTuple matchThreshold, string estimationMethod, HTuple distanceThreshold, int randSeed, out double error, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(358);
			HalconAPI.Store(proc, 1, image1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.StoreS(proc, 4, grayMatchMethod);
			HalconAPI.StoreI(proc, 5, maskSize);
			HalconAPI.StoreI(proc, 6, rowMove);
			HalconAPI.StoreI(proc, 7, colMove);
			HalconAPI.StoreI(proc, 8, rowTolerance);
			HalconAPI.StoreI(proc, 9, colTolerance);
			HalconAPI.Store(proc, 10, rotation);
			HalconAPI.Store(proc, 11, matchThreshold);
			HalconAPI.StoreS(proc, 12, estimationMethod);
			HalconAPI.Store(proc, 13, distanceThreshold);
			HalconAPI.StoreI(proc, 14, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(rotation);
			HalconAPI.UnpinTuple(matchThreshold);
			HalconAPI.UnpinTuple(distanceThreshold);
			num = base.Load(proc, 0, num);
			double result;
			num = HalconAPI.LoadD(proc, 1, num, out result);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image1);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute the fundamental matrix and the radial distortion coefficient for a pair of stereo images by automatically finding correspondences between image points.
		///   Modified instance represents: Computed fundamental matrix.
		/// </summary>
		/// <param name="image1">Input image 1.</param>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Input points in image 1 (row coordinate).</param>
		/// <param name="cols1">Input points in image 1 (column coordinate).</param>
		/// <param name="rows2">Input points in image 2 (row coordinate).</param>
		/// <param name="cols2">Input points in image 2 (column coordinate).</param>
		/// <param name="grayMatchMethod">Gray value match metric. Default: "ncc"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="rowMove">Average row coordinate offset of corresponding points. Default: 0</param>
		/// <param name="colMove">Average column coordinate offset of corresponding points. Default: 0</param>
		/// <param name="rowTolerance">Half height of matching search window. Default: 200</param>
		/// <param name="colTolerance">Half width of matching search window. Default: 200</param>
		/// <param name="rotation">Estimate of the relative rotation of the second image with respect to the first image. Default: 0.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 0.7</param>
		/// <param name="estimationMethod">Algorithm for the computation of the fundamental matrix and for special camera orientations. Default: "gold_standard"</param>
		/// <param name="distanceThreshold">Maximal deviation of a point from its epipolar line. Default: 1</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="error">Root-Mean-Square epipolar distance error.</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Computed radial distortion coefficient.</returns>
		// Token: 0x06000625 RID: 1573 RVA: 0x00024190 File Offset: 0x00022390
		public double MatchFundamentalMatrixDistortionRansac(HImage image1, HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, string grayMatchMethod, int maskSize, int rowMove, int colMove, int rowTolerance, int colTolerance, double rotation, int matchThreshold, string estimationMethod, double distanceThreshold, int randSeed, out double error, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(358);
			HalconAPI.Store(proc, 1, image1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.StoreS(proc, 4, grayMatchMethod);
			HalconAPI.StoreI(proc, 5, maskSize);
			HalconAPI.StoreI(proc, 6, rowMove);
			HalconAPI.StoreI(proc, 7, colMove);
			HalconAPI.StoreI(proc, 8, rowTolerance);
			HalconAPI.StoreI(proc, 9, colTolerance);
			HalconAPI.StoreD(proc, 10, rotation);
			HalconAPI.StoreI(proc, 11, matchThreshold);
			HalconAPI.StoreS(proc, 12, estimationMethod);
			HalconAPI.StoreD(proc, 13, distanceThreshold);
			HalconAPI.StoreI(proc, 14, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			num = base.Load(proc, 0, num);
			double result;
			num = HalconAPI.LoadD(proc, 1, num, out result);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image1);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute the essential matrix for a pair of stereo images by automatically finding correspondences between image points.
		///   Instance represents: Camera matrix of the 1st camera.
		/// </summary>
		/// <param name="image1">Input image 1.</param>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Row coordinates of characteristic points in image 1.</param>
		/// <param name="cols1">Column coordinates of characteristic points in image 1.</param>
		/// <param name="rows2">Row coordinates of characteristic points in image 2.</param>
		/// <param name="cols2">Column coordinates of characteristic points in image 2.</param>
		/// <param name="camMat2">Camera matrix of the 2nd camera.</param>
		/// <param name="grayMatchMethod">Gray value comparison metric. Default: "ssd"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="rowMove">Average row coordinate shift of corresponding points. Default: 0</param>
		/// <param name="colMove">Average column coordinate shift of corresponding points. Default: 0</param>
		/// <param name="rowTolerance">Half height of matching search window. Default: 200</param>
		/// <param name="colTolerance">Half width of matching search window. Default: 200</param>
		/// <param name="rotation">Estimate of the relative orientation of the right image with respect to the left image. Default: 0.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 10</param>
		/// <param name="estimationMethod">Algorithm for the computation of the essential matrix and for special camera orientations. Default: "normalized_dlt"</param>
		/// <param name="distanceThreshold">Maximal deviation of a point from its epipolar line. Default: 1</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="covEMat">9x9 covariance matrix of the essential matrix.</param>
		/// <param name="error">Root-Mean-Square of the epipolar distance error.</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Computed essential matrix.</returns>
		// Token: 0x06000626 RID: 1574 RVA: 0x000242E0 File Offset: 0x000224E0
		public HHomMat2D MatchEssentialMatrixRansac(HImage image1, HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, HHomMat2D camMat2, string grayMatchMethod, int maskSize, int rowMove, int colMove, int rowTolerance, int colTolerance, HTuple rotation, HTuple matchThreshold, string estimationMethod, HTuple distanceThreshold, int randSeed, out HTuple covEMat, out HTuple error, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(360);
			base.Store(proc, 4);
			HalconAPI.Store(proc, 1, image1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.Store(proc, 5, camMat2);
			HalconAPI.StoreS(proc, 6, grayMatchMethod);
			HalconAPI.StoreI(proc, 7, maskSize);
			HalconAPI.StoreI(proc, 8, rowMove);
			HalconAPI.StoreI(proc, 9, colMove);
			HalconAPI.StoreI(proc, 10, rowTolerance);
			HalconAPI.StoreI(proc, 11, colTolerance);
			HalconAPI.Store(proc, 12, rotation);
			HalconAPI.Store(proc, 13, matchThreshold);
			HalconAPI.StoreS(proc, 14, estimationMethod);
			HalconAPI.Store(proc, 15, distanceThreshold);
			HalconAPI.StoreI(proc, 16, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(camMat2);
			HalconAPI.UnpinTuple(rotation);
			HalconAPI.UnpinTuple(matchThreshold);
			HalconAPI.UnpinTuple(distanceThreshold);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out covEMat);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image1);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute the essential matrix for a pair of stereo images by automatically finding correspondences between image points.
		///   Instance represents: Camera matrix of the 1st camera.
		/// </summary>
		/// <param name="image1">Input image 1.</param>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Row coordinates of characteristic points in image 1.</param>
		/// <param name="cols1">Column coordinates of characteristic points in image 1.</param>
		/// <param name="rows2">Row coordinates of characteristic points in image 2.</param>
		/// <param name="cols2">Column coordinates of characteristic points in image 2.</param>
		/// <param name="camMat2">Camera matrix of the 2nd camera.</param>
		/// <param name="grayMatchMethod">Gray value comparison metric. Default: "ssd"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="rowMove">Average row coordinate shift of corresponding points. Default: 0</param>
		/// <param name="colMove">Average column coordinate shift of corresponding points. Default: 0</param>
		/// <param name="rowTolerance">Half height of matching search window. Default: 200</param>
		/// <param name="colTolerance">Half width of matching search window. Default: 200</param>
		/// <param name="rotation">Estimate of the relative orientation of the right image with respect to the left image. Default: 0.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 10</param>
		/// <param name="estimationMethod">Algorithm for the computation of the essential matrix and for special camera orientations. Default: "normalized_dlt"</param>
		/// <param name="distanceThreshold">Maximal deviation of a point from its epipolar line. Default: 1</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="covEMat">9x9 covariance matrix of the essential matrix.</param>
		/// <param name="error">Root-Mean-Square of the epipolar distance error.</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>Computed essential matrix.</returns>
		// Token: 0x06000627 RID: 1575 RVA: 0x00024474 File Offset: 0x00022674
		public HHomMat2D MatchEssentialMatrixRansac(HImage image1, HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, HHomMat2D camMat2, string grayMatchMethod, int maskSize, int rowMove, int colMove, int rowTolerance, int colTolerance, double rotation, int matchThreshold, string estimationMethod, double distanceThreshold, int randSeed, out HTuple covEMat, out double error, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(360);
			base.Store(proc, 4);
			HalconAPI.Store(proc, 1, image1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.Store(proc, 5, camMat2);
			HalconAPI.StoreS(proc, 6, grayMatchMethod);
			HalconAPI.StoreI(proc, 7, maskSize);
			HalconAPI.StoreI(proc, 8, rowMove);
			HalconAPI.StoreI(proc, 9, colMove);
			HalconAPI.StoreI(proc, 10, rowTolerance);
			HalconAPI.StoreI(proc, 11, colTolerance);
			HalconAPI.StoreD(proc, 12, rotation);
			HalconAPI.StoreI(proc, 13, matchThreshold);
			HalconAPI.StoreS(proc, 14, estimationMethod);
			HalconAPI.StoreD(proc, 15, distanceThreshold);
			HalconAPI.StoreI(proc, 16, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(camMat2);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out covEMat);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image1);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute the fundamental matrix for a pair of stereo images by automatically finding correspondences between image points.
		///   Modified instance represents: Computed fundamental matrix.
		/// </summary>
		/// <param name="image1">Input image 1.</param>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Row coordinates of characteristic points in image 1.</param>
		/// <param name="cols1">Column coordinates of characteristic points in image 1.</param>
		/// <param name="rows2">Row coordinates of characteristic points in image 2.</param>
		/// <param name="cols2">Column coordinates of characteristic points in image 2.</param>
		/// <param name="grayMatchMethod">Gray value comparison metric. Default: "ssd"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="rowMove">Average row coordinate shift of corresponding points. Default: 0</param>
		/// <param name="colMove">Average column coordinate shift of corresponding points. Default: 0</param>
		/// <param name="rowTolerance">Half height of matching search window. Default: 200</param>
		/// <param name="colTolerance">Half width of matching search window. Default: 200</param>
		/// <param name="rotation">Estimate of the relative orientation of the right image with respect to the left image. Default: 0.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 10</param>
		/// <param name="estimationMethod">Algorithm for the computation of the fundamental matrix and for special camera orientations. Default: "normalized_dlt"</param>
		/// <param name="distanceThreshold">Maximal deviation of a point from its epipolar line. Default: 1</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="error">Root-Mean-Square of the epipolar distance error.</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>9x9 covariance matrix of the fundamental matrix.</returns>
		// Token: 0x06000628 RID: 1576 RVA: 0x000245F0 File Offset: 0x000227F0
		public HTuple MatchFundamentalMatrixRansac(HImage image1, HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, string grayMatchMethod, int maskSize, int rowMove, int colMove, int rowTolerance, int colTolerance, HTuple rotation, HTuple matchThreshold, string estimationMethod, HTuple distanceThreshold, int randSeed, out double error, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(361);
			HalconAPI.Store(proc, 1, image1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.StoreS(proc, 4, grayMatchMethod);
			HalconAPI.StoreI(proc, 5, maskSize);
			HalconAPI.StoreI(proc, 6, rowMove);
			HalconAPI.StoreI(proc, 7, colMove);
			HalconAPI.StoreI(proc, 8, rowTolerance);
			HalconAPI.StoreI(proc, 9, colTolerance);
			HalconAPI.Store(proc, 10, rotation);
			HalconAPI.Store(proc, 11, matchThreshold);
			HalconAPI.StoreS(proc, 12, estimationMethod);
			HalconAPI.Store(proc, 13, distanceThreshold);
			HalconAPI.StoreI(proc, 14, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(rotation);
			HalconAPI.UnpinTuple(matchThreshold);
			HalconAPI.UnpinTuple(distanceThreshold);
			num = base.Load(proc, 0, num);
			HTuple result;
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out result);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image1);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Compute the fundamental matrix for a pair of stereo images by automatically finding correspondences between image points.
		///   Modified instance represents: Computed fundamental matrix.
		/// </summary>
		/// <param name="image1">Input image 1.</param>
		/// <param name="image2">Input image 2.</param>
		/// <param name="rows1">Row coordinates of characteristic points in image 1.</param>
		/// <param name="cols1">Column coordinates of characteristic points in image 1.</param>
		/// <param name="rows2">Row coordinates of characteristic points in image 2.</param>
		/// <param name="cols2">Column coordinates of characteristic points in image 2.</param>
		/// <param name="grayMatchMethod">Gray value comparison metric. Default: "ssd"</param>
		/// <param name="maskSize">Size of gray value masks. Default: 10</param>
		/// <param name="rowMove">Average row coordinate shift of corresponding points. Default: 0</param>
		/// <param name="colMove">Average column coordinate shift of corresponding points. Default: 0</param>
		/// <param name="rowTolerance">Half height of matching search window. Default: 200</param>
		/// <param name="colTolerance">Half width of matching search window. Default: 200</param>
		/// <param name="rotation">Estimate of the relative orientation of the right image with respect to the left image. Default: 0.0</param>
		/// <param name="matchThreshold">Threshold for gray value matching. Default: 10</param>
		/// <param name="estimationMethod">Algorithm for the computation of the fundamental matrix and for special camera orientations. Default: "normalized_dlt"</param>
		/// <param name="distanceThreshold">Maximal deviation of a point from its epipolar line. Default: 1</param>
		/// <param name="randSeed">Seed for the random number generator. Default: 0</param>
		/// <param name="error">Root-Mean-Square of the epipolar distance error.</param>
		/// <param name="points1">Indices of matched input points in image 1.</param>
		/// <param name="points2">Indices of matched input points in image 2.</param>
		/// <returns>9x9 covariance matrix of the fundamental matrix.</returns>
		// Token: 0x06000629 RID: 1577 RVA: 0x00024758 File Offset: 0x00022958
		public HTuple MatchFundamentalMatrixRansac(HImage image1, HImage image2, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, string grayMatchMethod, int maskSize, int rowMove, int colMove, int rowTolerance, int colTolerance, double rotation, int matchThreshold, string estimationMethod, double distanceThreshold, int randSeed, out double error, out HTuple points1, out HTuple points2)
		{
			IntPtr proc = HalconAPI.PreCall(361);
			HalconAPI.Store(proc, 1, image1);
			HalconAPI.Store(proc, 2, image2);
			HalconAPI.Store(proc, 0, rows1);
			HalconAPI.Store(proc, 1, cols1);
			HalconAPI.Store(proc, 2, rows2);
			HalconAPI.Store(proc, 3, cols2);
			HalconAPI.StoreS(proc, 4, grayMatchMethod);
			HalconAPI.StoreI(proc, 5, maskSize);
			HalconAPI.StoreI(proc, 6, rowMove);
			HalconAPI.StoreI(proc, 7, colMove);
			HalconAPI.StoreI(proc, 8, rowTolerance);
			HalconAPI.StoreI(proc, 9, colTolerance);
			HalconAPI.StoreD(proc, 10, rotation);
			HalconAPI.StoreI(proc, 11, matchThreshold);
			HalconAPI.StoreS(proc, 12, estimationMethod);
			HalconAPI.StoreD(proc, 13, distanceThreshold);
			HalconAPI.StoreI(proc, 14, randSeed);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			num = base.Load(proc, 0, num);
			HTuple result;
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out result);
			num = HalconAPI.LoadD(proc, 2, num, out error);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out points1);
			num = HTuple.LoadNew(proc, 4, HTupleType.INTEGER, num, out points2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image1);
			GC.KeepAlive(image2);
			return result;
		}

		/// <summary>
		///   Apply a projective transformation to a region.
		///   Instance represents: Homogeneous projective transformation matrix.
		/// </summary>
		/// <param name="regions">Input regions.</param>
		/// <param name="interpolation">Interpolation method for the transformation. Default: "bilinear"</param>
		/// <returns>Output regions.</returns>
		// Token: 0x0600062A RID: 1578 RVA: 0x000248AC File Offset: 0x00022AAC
		public HRegion ProjectiveTransRegion(HRegion regions, string interpolation)
		{
			IntPtr proc = HalconAPI.PreCall(487);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.StoreS(proc, 1, interpolation);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
			return result;
		}

		/// <summary>
		///   Apply an arbitrary affine 2D transformation to regions.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="region">Region(s) to be rotated and scaled.</param>
		/// <param name="interpolate">Should the transformation be done using interpolation? Default: "nearest_neighbor"</param>
		/// <returns>Transformed output region(s).</returns>
		// Token: 0x0600062B RID: 1579 RVA: 0x00024910 File Offset: 0x00022B10
		public HRegion AffineTransRegion(HRegion region, string interpolate)
		{
			IntPtr proc = HalconAPI.PreCall(488);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, region);
			HalconAPI.StoreS(proc, 1, interpolate);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(region);
			return result;
		}

		/// <summary>
		///   Apply a projective transformation to an image and specify the output image size.
		///   Instance represents: Homogeneous projective transformation matrix.
		/// </summary>
		/// <param name="image">Input image.</param>
		/// <param name="interpolation">Interpolation method for the transformation. Default: "bilinear"</param>
		/// <param name="width">Output image width.</param>
		/// <param name="height">Output image height.</param>
		/// <param name="transformDomain">Should the domain of the input image also be transformed? Default: "false"</param>
		/// <returns>Output image.</returns>
		// Token: 0x0600062C RID: 1580 RVA: 0x00024974 File Offset: 0x00022B74
		public HImage ProjectiveTransImageSize(HImage image, string interpolation, int width, int height, string transformDomain)
		{
			IntPtr proc = HalconAPI.PreCall(1620);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreS(proc, 1, interpolation);
			HalconAPI.StoreI(proc, 2, width);
			HalconAPI.StoreI(proc, 3, height);
			HalconAPI.StoreS(proc, 4, transformDomain);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Apply a projective transformation to an image.
		///   Instance represents: Homogeneous projective transformation matrix.
		/// </summary>
		/// <param name="image">Input image.</param>
		/// <param name="interpolation">Interpolation method for the transformation. Default: "bilinear"</param>
		/// <param name="adaptImageSize">Adapt the size of the output image automatically? Default: "false"</param>
		/// <param name="transformDomain">Should the domain of the input image also be transformed? Default: "false"</param>
		/// <returns>Output image.</returns>
		// Token: 0x0600062D RID: 1581 RVA: 0x000249F4 File Offset: 0x00022BF4
		public HImage ProjectiveTransImage(HImage image, string interpolation, string adaptImageSize, string transformDomain)
		{
			IntPtr proc = HalconAPI.PreCall(1621);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreS(proc, 1, interpolation);
			HalconAPI.StoreS(proc, 2, adaptImageSize);
			HalconAPI.StoreS(proc, 3, transformDomain);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Apply an arbitrary affine 2D transformation to an image and specify the output image size.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="image">Input image.</param>
		/// <param name="interpolation">Type of interpolation. Default: "constant"</param>
		/// <param name="width">Width of the output image. Default: 640</param>
		/// <param name="height">Height of the output image. Default: 480</param>
		/// <returns>Transformed image.</returns>
		// Token: 0x0600062E RID: 1582 RVA: 0x00024A6C File Offset: 0x00022C6C
		public HImage AffineTransImageSize(HImage image, string interpolation, int width, int height)
		{
			IntPtr proc = HalconAPI.PreCall(1622);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreS(proc, 1, interpolation);
			HalconAPI.StoreI(proc, 2, width);
			HalconAPI.StoreI(proc, 3, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Apply an arbitrary affine 2D transformation to images.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="image">Input image.</param>
		/// <param name="interpolation">Type of interpolation. Default: "constant"</param>
		/// <param name="adaptImageSize">Adaption of size of result image. Default: "false"</param>
		/// <returns>Transformed image.</returns>
		// Token: 0x0600062F RID: 1583 RVA: 0x00024AE4 File Offset: 0x00022CE4
		public HImage AffineTransImage(HImage image, string interpolation, string adaptImageSize)
		{
			IntPtr proc = HalconAPI.PreCall(1623);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreS(proc, 1, interpolation);
			HalconAPI.StoreS(proc, 2, adaptImageSize);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Approximate an affine map from a displacement vector field.
		///   Modified instance represents: Output transformation matrix.
		/// </summary>
		/// <param name="vectorField">Input image.</param>
		// Token: 0x06000630 RID: 1584 RVA: 0x00024B50 File Offset: 0x00022D50
		public void VectorFieldToHomMat2d(HImage vectorField)
		{
			IntPtr proc = HalconAPI.PreCall(1631);
			HalconAPI.Store(proc, 1, vectorField);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(vectorField);
		}

		/// <summary>
		///   Compute a camera matrix from internal camera parameters.
		///   Modified instance represents: 3x3 projective camera matrix that corresponds to CameraParam.
		/// </summary>
		/// <param name="cameraParam">Internal camera parameters.</param>
		/// <param name="imageWidth">Width of the images that correspond to CameraMatrix.</param>
		/// <param name="imageHeight">Height of the images that correspond to CameraMatrix.</param>
		// Token: 0x06000631 RID: 1585 RVA: 0x00024B9C File Offset: 0x00022D9C
		public void CamParToCamMat(HCamPar cameraParam, out int imageWidth, out int imageHeight)
		{
			IntPtr proc = HalconAPI.PreCall(1905);
			HalconAPI.Store(proc, 0, cameraParam);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(cameraParam);
			num = base.Load(proc, 0, num);
			num = HalconAPI.LoadI(proc, 1, num, out imageWidth);
			num = HalconAPI.LoadI(proc, 2, num, out imageHeight);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Compute the internal camera parameters from a camera matrix.
		///   Instance represents: 3x3 projective camera matrix that determines the internal camera parameters.
		/// </summary>
		/// <param name="kappa">Kappa.</param>
		/// <param name="imageWidth">Width of the images that correspond to CameraMatrix.</param>
		/// <param name="imageHeight">Height of the images that correspond to CameraMatrix.</param>
		/// <returns>Internal camera parameters.</returns>
		// Token: 0x06000632 RID: 1586 RVA: 0x00024C18 File Offset: 0x00022E18
		public HCamPar CamMatToCamPar(double kappa, int imageWidth, int imageHeight)
		{
			IntPtr proc = HalconAPI.PreCall(1906);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, kappa);
			HalconAPI.StoreI(proc, 2, imageWidth);
			HalconAPI.StoreI(proc, 3, imageHeight);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HCamPar result;
			num = HCamPar.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Perform a self-calibration of a stationary projective camera.</summary>
		/// <param name="numImages">Number of different images that are used for the calibration.</param>
		/// <param name="imageWidth">Width of the images from which the points were extracted.</param>
		/// <param name="imageHeight">Height of the images from which the points were extracted.</param>
		/// <param name="referenceImage">Index of the reference image.</param>
		/// <param name="mappingSource">Indices of the source images of the transformations.</param>
		/// <param name="mappingDest">Indices of the target images of the transformations.</param>
		/// <param name="homMatrices2D">Array of 3x3 projective transformation matrices.</param>
		/// <param name="rows1">Row coordinates of corresponding points in the respective source images.</param>
		/// <param name="cols1">Column coordinates of corresponding points in the respective source images.</param>
		/// <param name="rows2">Row coordinates of corresponding points in the respective destination images.</param>
		/// <param name="cols2">Column coordinates of corresponding points in the respective destination images.</param>
		/// <param name="numCorrespondences">Number of point correspondences in the respective image pair.</param>
		/// <param name="estimationMethod">Estimation algorithm for the calibration. Default: "gold_standard"</param>
		/// <param name="cameraModel">Camera model to be used. Default: ["focus","principal_point"]</param>
		/// <param name="fixedCameraParams">Are the camera parameters identical for all images? Default: "true"</param>
		/// <param name="kappa">Radial distortion of the camera.</param>
		/// <param name="rotationMatrices">Array of 3x3 transformation matrices that determine rotation of the camera in the respective image.</param>
		/// <param name="x">X-Component of the direction vector of each point if EstimationMethod $=$ 'gold_standard' is used.</param>
		/// <param name="y">Y-Component of the direction vector of each point if EstimationMethod $=$ 'gold_standard' is used.</param>
		/// <param name="z">Z-Component of the direction vector of each point if EstimationMethod $=$ 'gold_standard' is used.</param>
		/// <param name="error">Average error per reconstructed point if EstimationMethod $=$ 'gold_standard' is used.</param>
		/// <returns>(Array of) 3x3 projective camera matrices that determine the internal camera parameters.</returns>
		// Token: 0x06000633 RID: 1587 RVA: 0x00024C80 File Offset: 0x00022E80
		public static HHomMat2D[] StationaryCameraSelfCalibration(int numImages, int imageWidth, int imageHeight, int referenceImage, HTuple mappingSource, HTuple mappingDest, HHomMat2D[] homMatrices2D, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, HTuple numCorrespondences, string estimationMethod, HTuple cameraModel, string fixedCameraParams, out HTuple kappa, out HHomMat2D[] rotationMatrices, out HTuple x, out HTuple y, out HTuple z, out HTuple error)
		{
			HTuple htuple = HData.ConcatArray(homMatrices2D);
			IntPtr proc = HalconAPI.PreCall(1907);
			HalconAPI.StoreI(proc, 0, numImages);
			HalconAPI.StoreI(proc, 1, imageWidth);
			HalconAPI.StoreI(proc, 2, imageHeight);
			HalconAPI.StoreI(proc, 3, referenceImage);
			HalconAPI.Store(proc, 4, mappingSource);
			HalconAPI.Store(proc, 5, mappingDest);
			HalconAPI.Store(proc, 6, htuple);
			HalconAPI.Store(proc, 7, rows1);
			HalconAPI.Store(proc, 8, cols1);
			HalconAPI.Store(proc, 9, rows2);
			HalconAPI.Store(proc, 10, cols2);
			HalconAPI.Store(proc, 11, numCorrespondences);
			HalconAPI.StoreS(proc, 12, estimationMethod);
			HalconAPI.Store(proc, 13, cameraModel);
			HalconAPI.StoreS(proc, 14, fixedCameraParams);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(mappingSource);
			HalconAPI.UnpinTuple(mappingDest);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(numCorrespondences);
			HalconAPI.UnpinTuple(cameraModel);
			HTuple data;
			num = HTuple.LoadNew(proc, 0, num, out data);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out kappa);
			HTuple data2;
			num = HTuple.LoadNew(proc, 2, num, out data2);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out x);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out y);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out z);
			num = HTuple.LoadNew(proc, 6, HTupleType.DOUBLE, num, out error);
			HalconAPI.PostCall(proc, num);
			rotationMatrices = HHomMat2D.SplitArray(data2);
			return HHomMat2D.SplitArray(data);
		}

		/// <summary>Perform a self-calibration of a stationary projective camera.</summary>
		/// <param name="numImages">Number of different images that are used for the calibration.</param>
		/// <param name="imageWidth">Width of the images from which the points were extracted.</param>
		/// <param name="imageHeight">Height of the images from which the points were extracted.</param>
		/// <param name="referenceImage">Index of the reference image.</param>
		/// <param name="mappingSource">Indices of the source images of the transformations.</param>
		/// <param name="mappingDest">Indices of the target images of the transformations.</param>
		/// <param name="homMatrices2D">Array of 3x3 projective transformation matrices.</param>
		/// <param name="rows1">Row coordinates of corresponding points in the respective source images.</param>
		/// <param name="cols1">Column coordinates of corresponding points in the respective source images.</param>
		/// <param name="rows2">Row coordinates of corresponding points in the respective destination images.</param>
		/// <param name="cols2">Column coordinates of corresponding points in the respective destination images.</param>
		/// <param name="numCorrespondences">Number of point correspondences in the respective image pair.</param>
		/// <param name="estimationMethod">Estimation algorithm for the calibration. Default: "gold_standard"</param>
		/// <param name="cameraModel">Camera model to be used. Default: ["focus","principal_point"]</param>
		/// <param name="fixedCameraParams">Are the camera parameters identical for all images? Default: "true"</param>
		/// <param name="kappa">Radial distortion of the camera.</param>
		/// <param name="rotationMatrices">Array of 3x3 transformation matrices that determine rotation of the camera in the respective image.</param>
		/// <param name="x">X-Component of the direction vector of each point if EstimationMethod $=$ 'gold_standard' is used.</param>
		/// <param name="y">Y-Component of the direction vector of each point if EstimationMethod $=$ 'gold_standard' is used.</param>
		/// <param name="z">Z-Component of the direction vector of each point if EstimationMethod $=$ 'gold_standard' is used.</param>
		/// <param name="error">Average error per reconstructed point if EstimationMethod $=$ 'gold_standard' is used.</param>
		/// <returns>(Array of) 3x3 projective camera matrices that determine the internal camera parameters.</returns>
		// Token: 0x06000634 RID: 1588 RVA: 0x00024E10 File Offset: 0x00023010
		public static HHomMat2D[] StationaryCameraSelfCalibration(int numImages, int imageWidth, int imageHeight, int referenceImage, HTuple mappingSource, HTuple mappingDest, HHomMat2D[] homMatrices2D, HTuple rows1, HTuple cols1, HTuple rows2, HTuple cols2, HTuple numCorrespondences, string estimationMethod, HTuple cameraModel, string fixedCameraParams, out double kappa, out HHomMat2D[] rotationMatrices, out HTuple x, out HTuple y, out HTuple z, out double error)
		{
			HTuple htuple = HData.ConcatArray(homMatrices2D);
			IntPtr proc = HalconAPI.PreCall(1907);
			HalconAPI.StoreI(proc, 0, numImages);
			HalconAPI.StoreI(proc, 1, imageWidth);
			HalconAPI.StoreI(proc, 2, imageHeight);
			HalconAPI.StoreI(proc, 3, referenceImage);
			HalconAPI.Store(proc, 4, mappingSource);
			HalconAPI.Store(proc, 5, mappingDest);
			HalconAPI.Store(proc, 6, htuple);
			HalconAPI.Store(proc, 7, rows1);
			HalconAPI.Store(proc, 8, cols1);
			HalconAPI.Store(proc, 9, rows2);
			HalconAPI.Store(proc, 10, cols2);
			HalconAPI.Store(proc, 11, numCorrespondences);
			HalconAPI.StoreS(proc, 12, estimationMethod);
			HalconAPI.Store(proc, 13, cameraModel);
			HalconAPI.StoreS(proc, 14, fixedCameraParams);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(mappingSource);
			HalconAPI.UnpinTuple(mappingDest);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.UnpinTuple(rows1);
			HalconAPI.UnpinTuple(cols1);
			HalconAPI.UnpinTuple(rows2);
			HalconAPI.UnpinTuple(cols2);
			HalconAPI.UnpinTuple(numCorrespondences);
			HalconAPI.UnpinTuple(cameraModel);
			HTuple data;
			num = HTuple.LoadNew(proc, 0, num, out data);
			num = HalconAPI.LoadD(proc, 1, num, out kappa);
			HTuple data2;
			num = HTuple.LoadNew(proc, 2, num, out data2);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out x);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out y);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out z);
			num = HalconAPI.LoadD(proc, 6, num, out error);
			HalconAPI.PostCall(proc, num);
			rotationMatrices = HHomMat2D.SplitArray(data2);
			return HHomMat2D.SplitArray(data);
		}

		// Token: 0x0400088E RID: 2190
		private const int FIXEDSIZE = 9;
	}
}
